]> 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
reSWIGged
[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_wxEventBlocker swig_types[51]
2518 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
2519 #define SWIGTYPE_p_wxFSFile swig_types[53]
2520 #define SWIGTYPE_p_wxFileConfig swig_types[54]
2521 #define SWIGTYPE_p_wxFileDataObject swig_types[55]
2522 #define SWIGTYPE_p_wxFileHistory swig_types[56]
2523 #define SWIGTYPE_p_wxFileSystem swig_types[57]
2524 #define SWIGTYPE_p_wxFileType swig_types[58]
2525 #define SWIGTYPE_p_wxFileTypeInfo swig_types[59]
2526 #define SWIGTYPE_p_wxFlexGridSizer swig_types[60]
2527 #define SWIGTYPE_p_wxFocusEvent swig_types[61]
2528 #define SWIGTYPE_p_wxFont swig_types[62]
2529 #define SWIGTYPE_p_wxFrame swig_types[63]
2530 #define SWIGTYPE_p_wxGBSizerItem swig_types[64]
2531 #define SWIGTYPE_p_wxGIFHandler swig_types[65]
2532 #define SWIGTYPE_p_wxGridBagSizer swig_types[66]
2533 #define SWIGTYPE_p_wxGridSizer swig_types[67]
2534 #define SWIGTYPE_p_wxICOHandler swig_types[68]
2535 #define SWIGTYPE_p_wxIcon swig_types[69]
2536 #define SWIGTYPE_p_wxIconizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxIdleEvent swig_types[71]
2538 #define SWIGTYPE_p_wxImage swig_types[72]
2539 #define SWIGTYPE_p_wxImageHandler swig_types[73]
2540 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[74]
2541 #define SWIGTYPE_p_wxInitDialogEvent swig_types[75]
2542 #define SWIGTYPE_p_wxJPEGHandler swig_types[76]
2543 #define SWIGTYPE_p_wxJoystick swig_types[77]
2544 #define SWIGTYPE_p_wxJoystickEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKeyEvent swig_types[79]
2546 #define SWIGTYPE_p_wxKillError swig_types[80]
2547 #define SWIGTYPE_p_wxLayoutConstraints swig_types[81]
2548 #define SWIGTYPE_p_wxLog swig_types[82]
2549 #define SWIGTYPE_p_wxLogBuffer swig_types[83]
2550 #define SWIGTYPE_p_wxLogChain swig_types[84]
2551 #define SWIGTYPE_p_wxLogGui swig_types[85]
2552 #define SWIGTYPE_p_wxLogNull swig_types[86]
2553 #define SWIGTYPE_p_wxLogStderr swig_types[87]
2554 #define SWIGTYPE_p_wxLogTextCtrl swig_types[88]
2555 #define SWIGTYPE_p_wxLogWindow swig_types[89]
2556 #define SWIGTYPE_p_wxMaximizeEvent swig_types[90]
2557 #define SWIGTYPE_p_wxMenu swig_types[91]
2558 #define SWIGTYPE_p_wxMenuBar swig_types[92]
2559 #define SWIGTYPE_p_wxMenuEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenuItem swig_types[94]
2561 #define SWIGTYPE_p_wxMetafile swig_types[95]
2562 #define SWIGTYPE_p_wxMetafileDataObject swig_types[96]
2563 #define SWIGTYPE_p_wxMimeTypesManager swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMouseState swig_types[101]
2568 #define SWIGTYPE_p_wxMoveEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[103]
2570 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNcPaintEvent swig_types[105]
2572 #define SWIGTYPE_p_wxNotifyEvent swig_types[106]
2573 #define SWIGTYPE_p_wxObject swig_types[107]
2574 #define SWIGTYPE_p_wxOutputStream swig_types[108]
2575 #define SWIGTYPE_p_wxPCXHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNGHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPNMHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPaintEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[113]
2580 #define SWIGTYPE_p_wxPaperSize swig_types[114]
2581 #define SWIGTYPE_p_wxPlatformInfo swig_types[115]
2582 #define SWIGTYPE_p_wxPoint swig_types[116]
2583 #define SWIGTYPE_p_wxPowerEvent swig_types[117]
2584 #define SWIGTYPE_p_wxProcessEvent swig_types[118]
2585 #define SWIGTYPE_p_wxPyApp swig_types[119]
2586 #define SWIGTYPE_p_wxPyArtProvider swig_types[120]
2587 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[121]
2588 #define SWIGTYPE_p_wxPyCommandEvent swig_types[122]
2589 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropSource swig_types[124]
2591 #define SWIGTYPE_p_wxPyDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyEvent swig_types[126]
2593 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[127]
2594 #define SWIGTYPE_p_wxPyImageHandler swig_types[128]
2595 #define SWIGTYPE_p_wxPyLog swig_types[129]
2596 #define SWIGTYPE_p_wxPyProcess swig_types[130]
2597 #define SWIGTYPE_p_wxPySizer swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDataObject swig_types[132]
2599 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[133]
2600 #define SWIGTYPE_p_wxPyTimer swig_types[134]
2601 #define SWIGTYPE_p_wxPyTipProvider swig_types[135]
2602 #define SWIGTYPE_p_wxPyValidator swig_types[136]
2603 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[137]
2604 #define SWIGTYPE_p_wxRect swig_types[138]
2605 #define SWIGTYPE_p_wxScrollEvent swig_types[139]
2606 #define SWIGTYPE_p_wxScrollWinEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSetCursorEvent swig_types[141]
2608 #define SWIGTYPE_p_wxShowEvent swig_types[142]
2609 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[143]
2610 #define SWIGTYPE_p_wxSize swig_types[144]
2611 #define SWIGTYPE_p_wxSizeEvent swig_types[145]
2612 #define SWIGTYPE_p_wxSizer swig_types[146]
2613 #define SWIGTYPE_p_wxSizerItem swig_types[147]
2614 #define SWIGTYPE_p_wxSound swig_types[148]
2615 #define SWIGTYPE_p_wxStandardPaths swig_types[149]
2616 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[151]
2618 #define SWIGTYPE_p_wxStopWatch swig_types[152]
2619 #define SWIGTYPE_p_wxString swig_types[153]
2620 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[154]
2621 #define SWIGTYPE_p_wxSystemOptions swig_types[155]
2622 #define SWIGTYPE_p_wxSystemSettings swig_types[156]
2623 #define SWIGTYPE_p_wxTGAHandler swig_types[157]
2624 #define SWIGTYPE_p_wxTIFFHandler swig_types[158]
2625 #define SWIGTYPE_p_wxTextCtrl swig_types[159]
2626 #define SWIGTYPE_p_wxTextDataObject swig_types[160]
2627 #define SWIGTYPE_p_wxTimeSpan swig_types[161]
2628 #define SWIGTYPE_p_wxTimer swig_types[162]
2629 #define SWIGTYPE_p_wxTimerEvent swig_types[163]
2630 #define SWIGTYPE_p_wxTimerRunner swig_types[164]
2631 #define SWIGTYPE_p_wxTipProvider swig_types[165]
2632 #define SWIGTYPE_p_wxToolTip swig_types[166]
2633 #define SWIGTYPE_p_wxURLDataObject swig_types[167]
2634 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[168]
2635 #define SWIGTYPE_p_wxValidator swig_types[169]
2636 #define SWIGTYPE_p_wxVideoMode swig_types[170]
2637 #define SWIGTYPE_p_wxWindow swig_types[171]
2638 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[172]
2639 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[173]
2640 #define SWIGTYPE_p_wxWindowDisabler swig_types[174]
2641 #define SWIGTYPE_p_wxXPMHandler swig_types[175]
2642 static swig_type_info *swig_types[177];
2643 static swig_module_info swig_module = {swig_types, 176, 0, 0, 0, 0};
2644 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2645 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2646
2647 /* -------- TYPES TABLE (END) -------- */
2648
2649 #if (PY_VERSION_HEX <= 0x02000000)
2650 # if !defined(SWIG_PYTHON_CLASSIC)
2651 # error "This python version requires to use swig with the '-classic' option"
2652 # endif
2653 #endif
2654 #if (PY_VERSION_HEX <= 0x02020000)
2655 # error "This python version requires to use swig with the '-nomodern' option"
2656 #endif
2657 #if (PY_VERSION_HEX <= 0x02020000)
2658 # error "This python version requires to use swig with the '-nomodernargs' option"
2659 #endif
2660 #ifndef METH_O
2661 # error "This python version requires to use swig with the '-nofastunpack' option"
2662 #endif
2663
2664 /*-----------------------------------------------
2665 @(target):= _misc_.so
2666 ------------------------------------------------*/
2667 #define SWIG_init init_misc_
2668
2669 #define SWIG_name "_misc_"
2670
2671 #define SWIGVERSION 0x010329
2672
2673
2674 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2675 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2676
2677
2678 #include <stdexcept>
2679
2680
2681 namespace swig {
2682 class PyObject_ptr {
2683 protected:
2684 PyObject *_obj;
2685
2686 public:
2687 PyObject_ptr() :_obj(0)
2688 {
2689 }
2690
2691 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2692 {
2693 Py_XINCREF(_obj);
2694 }
2695
2696 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2697 {
2698 if (initial_ref) Py_XINCREF(_obj);
2699 }
2700
2701 PyObject_ptr & operator=(const PyObject_ptr& item)
2702 {
2703 Py_XINCREF(item._obj);
2704 Py_XDECREF(_obj);
2705 _obj = item._obj;
2706 return *this;
2707 }
2708
2709 ~PyObject_ptr()
2710 {
2711 Py_XDECREF(_obj);
2712 }
2713
2714 operator PyObject *() const
2715 {
2716 return _obj;
2717 }
2718
2719 PyObject *operator->() const
2720 {
2721 return _obj;
2722 }
2723 };
2724 }
2725
2726
2727 namespace swig {
2728 struct PyObject_var : PyObject_ptr {
2729 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2730
2731 PyObject_var & operator = (PyObject* obj)
2732 {
2733 Py_XDECREF(_obj);
2734 _obj = obj;
2735 return *this;
2736 }
2737 };
2738 }
2739
2740
2741 #include "wx/wxPython/wxPython.h"
2742 #include "wx/wxPython/pyclasses.h"
2743 #include "wx/wxPython/pyistream.h"
2744
2745 static const wxString wxPyEmptyString(wxEmptyString);
2746
2747
2748
2749 #define SWIG_From_long PyInt_FromLong
2750
2751
2752 SWIGINTERNINLINE PyObject *
2753 SWIG_From_int (int value)
2754 {
2755 return SWIG_From_long (value);
2756 }
2757
2758
2759 #include <limits.h>
2760 #ifndef LLONG_MIN
2761 # define LLONG_MIN LONG_LONG_MIN
2762 #endif
2763 #ifndef LLONG_MAX
2764 # define LLONG_MAX LONG_LONG_MAX
2765 #endif
2766 #ifndef ULLONG_MAX
2767 # define ULLONG_MAX ULONG_LONG_MAX
2768 #endif
2769
2770
2771 SWIGINTERN int
2772 SWIG_AsVal_long (PyObject* obj, long* val)
2773 {
2774 if (PyNumber_Check(obj)) {
2775 if (val) *val = PyInt_AsLong(obj);
2776 return SWIG_OK;
2777 }
2778 return SWIG_TypeError;
2779 }
2780
2781
2782 SWIGINTERN int
2783 SWIG_AsVal_int (PyObject * obj, int *val)
2784 {
2785 long v;
2786 int res = SWIG_AsVal_long (obj, &v);
2787 if (SWIG_IsOK(res)) {
2788 if ((v < INT_MIN || v > INT_MAX)) {
2789 return SWIG_OverflowError;
2790 } else {
2791 if (val) *val = static_cast< int >(v);
2792 }
2793 }
2794 return res;
2795 }
2796
2797 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2798
2799 #include <wx/stockitem.h>
2800
2801 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2802 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2803 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2804
2805 SWIGINTERN int
2806 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2807 {
2808 long v = 0;
2809 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2810 return SWIG_TypeError;
2811 }
2812 else if (val)
2813 *val = (unsigned long)v;
2814 return SWIG_OK;
2815 }
2816
2817
2818 SWIGINTERN int
2819 SWIG_AsVal_bool (PyObject *obj, bool *val)
2820 {
2821 if (obj == Py_True) {
2822 if (val) *val = true;
2823 return SWIG_OK;
2824 } else if (obj == Py_False) {
2825 if (val) *val = false;
2826 return SWIG_OK;
2827 } else {
2828 long v = 0;
2829 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2830 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2831 return res;
2832 }
2833 }
2834
2835
2836 SWIGINTERNINLINE PyObject*
2837 SWIG_From_unsigned_SS_long (unsigned long value)
2838 {
2839 return (value > LONG_MAX) ?
2840 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2841 }
2842
2843
2844 void* wxGetXDisplay()
2845 {
2846 #ifdef __WXGTK__
2847 return wxGetDisplay();
2848 #else
2849 return NULL;
2850 #endif
2851 }
2852
2853
2854 wxWindow* FindWindowAtPointer() {
2855 wxPoint unused;
2856 return wxFindWindowAtPointer(unused);
2857 }
2858
2859
2860 bool wxThread_IsMain() {
2861 #ifdef WXP_WITH_THREAD
2862 return wxThread::IsMain();
2863 #else
2864 return true;
2865 #endif
2866 }
2867
2868 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2869 delete self;
2870 }
2871
2872 #include <wx/snglinst.h>
2873
2874
2875 #ifdef __WXMSW__
2876 #include <wx/msw/private.h>
2877 #include <wx/dynload.h>
2878 #endif
2879
2880
2881
2882 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2883 #if 0
2884 , int method
2885 #endif
2886 )
2887 {
2888 #ifdef __WXMSW__
2889 #if 0
2890 switch (method)
2891 {
2892 case 1:
2893 // This one only partially works. Appears to be an undocumented
2894 // "standard" convention that not all widgets adhear to. For
2895 // example, for some widgets backgrounds or non-client areas may
2896 // not be painted.
2897 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2898 break;
2899
2900 case 2:
2901 #endif
2902 // This one works much better, nearly all widgets and their
2903 // children are captured correctly[**]. Prior to the big
2904 // background erase changes that Vadim did in 2004-2005 this
2905 // method failed badly on XP with Themes activated, most native
2906 // widgets draw only partially, if at all. Without themes it
2907 // worked just like on Win2k. After those changes this method
2908 // works very well.
2909 //
2910 // ** For example the radio buttons in a wxRadioBox are not its
2911 // children by default, but you can capture it via the panel
2912 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2913 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2914 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2915 PRF_ERASEBKGND | PRF_OWNED );
2916 return true;
2917 #if 0
2918 break;
2919
2920 case 3:
2921 // This one is only defined in the latest SDK and is only
2922 // available on XP. MSDN says it is similar to sending WM_PRINT
2923 // so I expect that it will work similar to the above. Since it
2924 // is avaialble only on XP, it can't be compiled like this and
2925 // will have to be loaded dynamically.
2926 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2927
2928 // fall through
2929
2930 case 4:
2931 // Use PrintWindow if available, or fallback to WM_PRINT
2932 // otherwise. Unfortunately using PrintWindow is even worse than
2933 // WM_PRINT. For most native widgets nothing is drawn to the dc
2934 // at all, with or without Themes.
2935 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2936 static bool s_triedToLoad = false;
2937 static PrintWindow_t pfnPrintWindow = NULL;
2938 if ( !s_triedToLoad )
2939 {
2940
2941 s_triedToLoad = true;
2942 wxDynamicLibrary dllUser32(_T("user32.dll"));
2943 if ( dllUser32.IsLoaded() )
2944 {
2945 wxLogNull nolog; // Don't report errors here
2946 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2947 }
2948 }
2949 if (pfnPrintWindow)
2950 {
2951 //printf("Using PrintWindow\n");
2952 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2953 }
2954 else
2955 {
2956 //printf("Using WM_PRINT\n");
2957 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2958 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2959 PRF_ERASEBKGND | PRF_OWNED );
2960 }
2961 }
2962 #endif // 0
2963 #else
2964 return false;
2965 #endif // __WXMSW__
2966 }
2967
2968
2969
2970 #include <wx/tipdlg.h>
2971
2972
2973 SWIGINTERNINLINE PyObject *
2974 SWIG_From_size_t (size_t value)
2975 {
2976 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2977 }
2978
2979
2980 class wxPyTipProvider : public wxTipProvider {
2981 public:
2982 wxPyTipProvider(size_t currentTip)
2983 : wxTipProvider(currentTip) {}
2984
2985 DEC_PYCALLBACK_STRING__pure(GetTip);
2986 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2987 PYPRIVATE;
2988 };
2989
2990 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2991 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2992
2993
2994 SWIGINTERNINLINE int
2995 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2996 {
2997 unsigned long v;
2998 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2999 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3000 return res;
3001 }
3002
3003
3004 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3005
3006 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3007
3008 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3009 : wxTimer(owner, id)
3010 {
3011 if (owner == NULL)
3012 SetOwner(this);
3013 }
3014
3015 wxPyTimer::~wxPyTimer()
3016 {
3017 // printf("-=* ~wxPyTimer\n");
3018 }
3019
3020
3021
3022 SWIGINTERN swig_type_info*
3023 SWIG_pchar_descriptor()
3024 {
3025 static int init = 0;
3026 static swig_type_info* info = 0;
3027 if (!init) {
3028 info = SWIG_TypeQuery("_p_char");
3029 init = 1;
3030 }
3031 return info;
3032 }
3033
3034
3035 SWIGINTERNINLINE PyObject *
3036 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3037 {
3038 if (carray) {
3039 if (size > INT_MAX) {
3040 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3041 return pchar_descriptor ?
3042 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3043 } else {
3044 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3045 }
3046 } else {
3047 return SWIG_Py_Void();
3048 }
3049 }
3050
3051
3052 SWIGINTERNINLINE PyObject *
3053 SWIG_FromCharPtr(const char *cptr)
3054 {
3055 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3056 }
3057
3058
3059 SWIGINTERN int
3060 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3061 {
3062 unsigned long v;
3063 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3064 if (SWIG_IsOK(res)) {
3065 if ((v > UINT_MAX)) {
3066 return SWIG_OverflowError;
3067 } else {
3068 if (val) *val = static_cast< unsigned int >(v);
3069 }
3070 }
3071 return res;
3072 }
3073
3074 SWIGINTERN wxString wxLog_TimeStamp(){
3075 wxString msg;
3076 wxLog::TimeStamp(&msg);
3077 return msg;
3078 }
3079 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3080 // Make some wrappers that double any % signs so they are 'escaped'
3081 void wxPyLogFatalError(const wxString& msg)
3082 {
3083 wxString m(msg);
3084 m.Replace(wxT("%"), wxT("%%"));
3085 wxLogFatalError(m);
3086 }
3087
3088 void wxPyLogError(const wxString& msg)
3089 {
3090 wxString m(msg);
3091 m.Replace(wxT("%"), wxT("%%"));
3092 wxLogError(m);
3093 }
3094
3095 void wxPyLogWarning(const wxString& msg)
3096 {
3097 wxString m(msg);
3098 m.Replace(wxT("%"), wxT("%%"));
3099 wxLogWarning(m);
3100 }
3101
3102 void wxPyLogMessage(const wxString& msg)
3103 {
3104 wxString m(msg);
3105 m.Replace(wxT("%"), wxT("%%"));
3106 wxLogMessage(m);
3107 }
3108
3109 void wxPyLogInfo(const wxString& msg)
3110 {
3111 wxString m(msg);
3112 m.Replace(wxT("%"), wxT("%%"));
3113 wxLogInfo(m);
3114 }
3115
3116 void wxPyLogDebug(const wxString& msg)
3117 {
3118 wxString m(msg);
3119 m.Replace(wxT("%"), wxT("%%"));
3120 wxLogDebug(m);
3121 }
3122
3123 void wxPyLogVerbose(const wxString& msg)
3124 {
3125 wxString m(msg);
3126 m.Replace(wxT("%"), wxT("%%"));
3127 wxLogVerbose(m);
3128 }
3129
3130 void wxPyLogStatus(const wxString& msg)
3131 {
3132 wxString m(msg);
3133 m.Replace(wxT("%"), wxT("%%"));
3134 wxLogStatus(m);
3135 }
3136
3137 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3138 {
3139 wxString m(msg);
3140 m.Replace(wxT("%"), wxT("%%"));
3141 wxLogStatus(pFrame, m);
3142 }
3143
3144 void wxPyLogSysError(const wxString& msg)
3145 {
3146 wxString m(msg);
3147 m.Replace(wxT("%"), wxT("%%"));
3148 wxLogSysError(m);
3149 }
3150
3151 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3152 {
3153 wxString m(msg);
3154 m.Replace(wxT("%"), wxT("%%"));
3155 wxLogGeneric(level, m);
3156 }
3157
3158 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3159 {
3160 wxString m(msg);
3161 m.Replace(wxT("%"), wxT("%%"));
3162 wxLogTrace(mask, m);
3163 }
3164
3165 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3166 {
3167 wxString m(msg);
3168 m.Replace(wxT("%"), wxT("%%"));
3169 wxLogTrace(mask, m);
3170 }
3171
3172
3173
3174 // A wxLog class that can be derived from in wxPython
3175 class wxPyLog : public wxLog {
3176 public:
3177 wxPyLog() : wxLog() {}
3178
3179 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3180 bool found;
3181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3182 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3183 PyObject* s = wx2PyString(szString);
3184 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3185 Py_DECREF(s);
3186 }
3187 wxPyEndBlockThreads(blocked);
3188 if (! found)
3189 wxLog::DoLog(level, szString, t);
3190 }
3191
3192 virtual void DoLogString(const wxChar *szString, time_t t) {
3193 bool found;
3194 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3195 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3196 PyObject* s = wx2PyString(szString);
3197 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3198 Py_DECREF(s);
3199 }
3200 wxPyEndBlockThreads(blocked);
3201 if (! found)
3202 wxLog::DoLogString(szString, t);
3203 }
3204
3205 DEC_PYCALLBACK_VOID_(Flush);
3206 PYPRIVATE;
3207 };
3208 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3209
3210
3211
3212
3213 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3214
3215
3216 #include <wx/joystick.h>
3217
3218
3219 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3220 // A C++ stub class for wxJoystick for platforms that don't have it.
3221 class wxJoystick : public wxObject {
3222 public:
3223 wxJoystick(int joystick = wxJOYSTICK1) {
3224 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3225 PyErr_SetString(PyExc_NotImplementedError,
3226 "wxJoystick is not available on this platform.");
3227 wxPyEndBlockThreads(blocked);
3228 }
3229 wxPoint GetPosition() { return wxPoint(-1,-1); }
3230 int GetZPosition() { return -1; }
3231 int GetButtonState() { return -1; }
3232 int GetPOVPosition() { return -1; }
3233 int GetPOVCTSPosition() { return -1; }
3234 int GetRudderPosition() { return -1; }
3235 int GetUPosition() { return -1; }
3236 int GetVPosition() { return -1; }
3237 int GetMovementThreshold() { return -1; }
3238 void SetMovementThreshold(int threshold) {}
3239
3240 bool IsOk(void) { return false; }
3241 int GetNumberJoysticks() { return -1; }
3242 int GetManufacturerId() { return -1; }
3243 int GetProductId() { return -1; }
3244 wxString GetProductName() { return wxEmptyString; }
3245 int GetXMin() { return -1; }
3246 int GetYMin() { return -1; }
3247 int GetZMin() { return -1; }
3248 int GetXMax() { return -1; }
3249 int GetYMax() { return -1; }
3250 int GetZMax() { return -1; }
3251 int GetNumberButtons() { return -1; }
3252 int GetNumberAxes() { return -1; }
3253 int GetMaxButtons() { return -1; }
3254 int GetMaxAxes() { return -1; }
3255 int GetPollingMin() { return -1; }
3256 int GetPollingMax() { return -1; }
3257 int GetRudderMin() { return -1; }
3258 int GetRudderMax() { return -1; }
3259 int GetUMin() { return -1; }
3260 int GetUMax() { return -1; }
3261 int GetVMin() { return -1; }
3262 int GetVMax() { return -1; }
3263
3264 bool HasRudder() { return false; }
3265 bool HasZ() { return false; }
3266 bool HasU() { return false; }
3267 bool HasV() { return false; }
3268 bool HasPOV() { return false; }
3269 bool HasPOV4Dir() { return false; }
3270 bool HasPOVCTS() { return false; }
3271
3272 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3273 bool ReleaseCapture() { return false; }
3274 };
3275 #endif
3276
3277
3278 #include <wx/sound.h>
3279
3280
3281 #if !wxUSE_SOUND
3282 // A C++ stub class for wxWave for platforms that don't have it.
3283 class wxSound : public wxObject
3284 {
3285 public:
3286 wxSound() {
3287 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3288 PyErr_SetString(PyExc_NotImplementedError,
3289 "wxSound is not available on this platform.");
3290 wxPyEndBlockThreads(blocked);
3291 }
3292 wxSound(const wxString&/*, bool*/) {
3293 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3294 PyErr_SetString(PyExc_NotImplementedError,
3295 "wxSound is not available on this platform.");
3296 wxPyEndBlockThreads(blocked);
3297 }
3298 wxSound(int, const wxByte*) {
3299 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3300 PyErr_SetString(PyExc_NotImplementedError,
3301 "wxSound is not available on this platform.");
3302 wxPyEndBlockThreads(blocked);
3303 }
3304
3305 ~wxSound() {};
3306
3307 bool Create(const wxString&/*, bool*/) { return false; }
3308 bool Create(int, const wxByte*) { return false; };
3309 bool IsOk() { return false; };
3310 bool Play(unsigned) const { return false; }
3311 static bool Play(const wxString&, unsigned) { return false; }
3312 static void Stop() {}
3313 };
3314
3315 #endif
3316
3317 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3318 if (fileName.Length() == 0)
3319 return new wxSound;
3320 else
3321 return new wxSound(fileName);
3322 }
3323 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3324 unsigned char* buffer; int size;
3325 wxSound *sound = NULL;
3326
3327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3328 if (!PyArg_Parse(data, "t#", &buffer, &size))
3329 goto done;
3330 sound = new wxSound(size, buffer);
3331 done:
3332 wxPyEndBlockThreads(blocked);
3333 return sound;
3334 }
3335 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3336 #ifndef __WXMAC__
3337 unsigned char* buffer;
3338 int size;
3339 bool rv = false;
3340
3341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3342 if (!PyArg_Parse(data, "t#", &buffer, &size))
3343 goto done;
3344 rv = self->Create(size, buffer);
3345 done:
3346 wxPyEndBlockThreads(blocked);
3347 return rv;
3348 #else
3349 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3350 PyErr_SetString(PyExc_NotImplementedError,
3351 "Create from data is not available on this platform.");
3352 wxPyEndBlockThreads(blocked);
3353 return false;
3354 #endif
3355 }
3356
3357 #include <wx/mimetype.h>
3358
3359 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3360 wxString str;
3361 if (self->GetMimeType(&str))
3362 return wx2PyString(str);
3363 else
3364 RETURN_NONE();
3365 }
3366 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3367 wxArrayString arr;
3368 if (self->GetMimeTypes(arr))
3369 return wxArrayString2PyList_helper(arr);
3370 else
3371 RETURN_NONE();
3372 }
3373 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3374 wxArrayString arr;
3375 if (self->GetExtensions(arr))
3376 return wxArrayString2PyList_helper(arr);
3377 else
3378 RETURN_NONE();
3379 }
3380 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3381 wxIconLocation loc;
3382 if (self->GetIcon(&loc))
3383 return new wxIcon(loc);
3384 else
3385 return NULL;
3386 }
3387 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3388 wxIconLocation loc;
3389 if (self->GetIcon(&loc)) {
3390 wxString iconFile = loc.GetFileName();
3391 int iconIndex = -1;
3392
3393
3394
3395 // Make a tuple and put the values in it
3396 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3397 PyObject* tuple = PyTuple_New(3);
3398 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3399 wxT("wxIcon"), true));
3400 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3401 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3402 wxPyEndBlockThreads(blocked);
3403 return tuple;
3404 }
3405 else
3406 RETURN_NONE();
3407 }
3408 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3409 wxString str;
3410 if (self->GetDescription(&str))
3411 return wx2PyString(str);
3412 else
3413 RETURN_NONE();
3414 }
3415 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3416 wxString str;
3417 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3418 return wx2PyString(str);
3419 else
3420 RETURN_NONE();
3421 }
3422 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3423 wxString str;
3424 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3425 return wx2PyString(str);
3426 else
3427 RETURN_NONE();
3428 }
3429 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3430 wxArrayString verbs;
3431 wxArrayString commands;
3432 if (self->GetAllCommands(&verbs, &commands,
3433 wxFileType::MessageParameters(filename, mimetype))) {
3434 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3435 PyObject* tuple = PyTuple_New(2);
3436 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3437 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3438 wxPyEndBlockThreads(blocked);
3439 return tuple;
3440 }
3441 else
3442 RETURN_NONE();
3443 }
3444 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3445 return wxFileType::ExpandCommand(command,
3446 wxFileType::MessageParameters(filename, mimetype));
3447 }
3448 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3449 wxArrayString arr;
3450 self->EnumAllFileTypes(arr);
3451 return wxArrayString2PyList_helper(arr);
3452 }
3453
3454 #include <wx/artprov.h>
3455
3456 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3457 static const wxString wxPyART_MENU(wxART_MENU);
3458 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3459 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3460 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3461 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3462 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3463 static const wxString wxPyART_OTHER(wxART_OTHER);
3464 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3465 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3466 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3467 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3468 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3469 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3470 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3471 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3472 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3473 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3474 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3475 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3476 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3477 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3478 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3479 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3480 static const wxString wxPyART_PRINT(wxART_PRINT);
3481 static const wxString wxPyART_HELP(wxART_HELP);
3482 static const wxString wxPyART_TIP(wxART_TIP);
3483 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3484 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3485 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3486 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3487 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3488 static const wxString wxPyART_CDROM(wxART_CDROM);
3489 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3490 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3491 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3492 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3493 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3494 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3495 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3496 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3497 static const wxString wxPyART_ERROR(wxART_ERROR);
3498 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3499 static const wxString wxPyART_WARNING(wxART_WARNING);
3500 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3501 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3502 static const wxString wxPyART_COPY(wxART_COPY);
3503 static const wxString wxPyART_CUT(wxART_CUT);
3504 static const wxString wxPyART_PASTE(wxART_PASTE);
3505 static const wxString wxPyART_DELETE(wxART_DELETE);
3506 static const wxString wxPyART_NEW(wxART_NEW);
3507 static const wxString wxPyART_UNDO(wxART_UNDO);
3508 static const wxString wxPyART_REDO(wxART_REDO);
3509 static const wxString wxPyART_QUIT(wxART_QUIT);
3510 static const wxString wxPyART_FIND(wxART_FIND);
3511 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3512 // Python aware wxArtProvider
3513 class wxPyArtProvider : public wxArtProvider {
3514 public:
3515
3516 virtual wxBitmap CreateBitmap(const wxArtID& id,
3517 const wxArtClient& client,
3518 const wxSize& size) {
3519 wxBitmap rval = wxNullBitmap;
3520 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3521 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3522 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3523 PyObject* ro;
3524 wxBitmap* ptr;
3525 PyObject* s1, *s2;
3526 s1 = wx2PyString(id);
3527 s2 = wx2PyString(client);
3528 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3529 Py_DECREF(so);
3530 Py_DECREF(s1);
3531 Py_DECREF(s2);
3532 if (ro) {
3533 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3534 rval = *ptr;
3535 Py_DECREF(ro);
3536 }
3537 }
3538 wxPyEndBlockThreads(blocked);
3539 return rval;
3540 }
3541
3542 PYPRIVATE;
3543 };
3544
3545 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3546
3547
3548
3549 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3550 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3551 PyObject* ret = PyTuple_New(3);
3552 if (ret) {
3553 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3554 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3555 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3556 }
3557 wxPyEndBlockThreads(blocked);
3558 return ret;
3559 }
3560
3561 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3562 bool cont;
3563 long index = 0;
3564 wxString value;
3565
3566 cont = self->GetFirstGroup(value, index);
3567 return __EnumerationHelper(cont, value, index);
3568 }
3569 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3570 bool cont;
3571 wxString value;
3572
3573 cont = self->GetNextGroup(value, index);
3574 return __EnumerationHelper(cont, value, index);
3575 }
3576 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3577 bool cont;
3578 long index = 0;
3579 wxString value;
3580
3581 cont = self->GetFirstEntry(value, index);
3582 return __EnumerationHelper(cont, value, index);
3583 }
3584 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3585 bool cont;
3586 wxString value;
3587
3588 cont = self->GetNextEntry(value, index);
3589 return __EnumerationHelper(cont, value, index);
3590 }
3591 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3592 long rv;
3593 self->Read(key, &rv, defaultVal);
3594 return rv;
3595 }
3596
3597 SWIGINTERN int
3598 SWIG_AsVal_double (PyObject *obj, double* val)
3599 {
3600 if (PyNumber_Check(obj)) {
3601 if (val) *val = PyFloat_AsDouble(obj);
3602 return SWIG_OK;
3603 }
3604 return SWIG_TypeError;
3605 }
3606
3607 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3608 double rv;
3609 self->Read(key, &rv, defaultVal);
3610 return rv;
3611 }
3612
3613 #define SWIG_From_double PyFloat_FromDouble
3614
3615 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3616 bool rv;
3617 self->Read(key, &rv, defaultVal);
3618 return rv;
3619 }
3620
3621 #include <wx/datetime.h>
3622
3623 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3624 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3625
3626 #define LOCAL_TZ wxDateTime::Local
3627
3628 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3629 wxString am;
3630 wxString pm;
3631 wxDateTime::GetAmPmStrings(&am, &pm);
3632 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3633 PyObject* tup = PyTuple_New(2);
3634 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3635 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3636 wxPyEndBlockThreads(blocked);
3637 return tup;
3638 }
3639
3640 SWIGINTERNINLINE PyObject *
3641 SWIG_From_unsigned_SS_int (unsigned int value)
3642 {
3643 return SWIG_From_unsigned_SS_long (value);
3644 }
3645
3646 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3647 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3648 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3649 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3650 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3651 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3653 return (*self < *other);
3654 }
3655 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3657 return (*self <= *other);
3658 }
3659 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3661 return (*self > *other);
3662 }
3663 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3664 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3665 return (*self >= *other);
3666 }
3667 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3668 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3669 return (*self == *other);
3670 }
3671 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3672 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3673 return (*self != *other);
3674 }
3675 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3676 const wxChar* rv;
3677 const wxChar* _date = date;
3678 rv = self->ParseRfc822Date(_date);
3679 if (rv == NULL) return -1;
3680 return rv - _date;
3681 }
3682 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3683 const wxChar* rv;
3684 const wxChar* _date = date;
3685 rv = self->ParseFormat(_date, format, dateDef);
3686 if (rv == NULL) return -1;
3687 return rv - _date;
3688 }
3689 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3690 const wxChar* rv;
3691 const wxChar* _datetime = datetime;
3692 rv = self->ParseDateTime(_datetime);
3693 if (rv == NULL) return -1;
3694 return rv - _datetime;
3695 }
3696 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3697 const wxChar* rv;
3698 const wxChar* _date = date;
3699 rv = self->ParseDate(_date);
3700 if (rv == NULL) return -1;
3701 return rv - _date;
3702 }
3703 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3704 const wxChar* rv;
3705 const wxChar* _time = time;
3706 rv = self->ParseTime(_time);
3707 if (rv == NULL) return -1;
3708 return rv - _time;
3709 }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3711 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3712 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3713 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3714 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3715 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3716 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3717 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3718 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3719 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3720 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3721 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3722 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3723 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3724 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3725 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3726
3727 #include <wx/dataobj.h>
3728
3729 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3730 size_t count = self->GetFormatCount(dir);
3731 wxDataFormat* formats = new wxDataFormat[count];
3732 self->GetAllFormats(formats, dir);
3733
3734 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3735 PyObject* list = PyList_New(count);
3736 for (size_t i=0; i<count; i++) {
3737 wxDataFormat* format = new wxDataFormat(formats[i]);
3738 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3739 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3740 }
3741 wxPyEndBlockThreads(blocked);
3742 delete [] formats;
3743 return list;
3744 }
3745 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3746 PyObject* rval = NULL;
3747 size_t size = self->GetDataSize(format);
3748 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3749 if (size) {
3750 char* buf = new char[size];
3751 if (self->GetDataHere(format, buf))
3752 rval = PyString_FromStringAndSize(buf, size);
3753 delete [] buf;
3754 }
3755 if (! rval) {
3756 rval = Py_None;
3757 Py_INCREF(rval);
3758 }
3759 wxPyEndBlockThreads(blocked);
3760 return rval;
3761 }
3762 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3763 bool rval;
3764 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3765 if (PyString_Check(data)) {
3766 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3767 }
3768 else {
3769 // raise a TypeError if not a string
3770 PyErr_SetString(PyExc_TypeError, "String expected.");
3771 rval = false;
3772 }
3773 wxPyEndBlockThreads(blocked);
3774 return rval;
3775 }
3776 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3777 PyObject* rval = NULL;
3778 size_t size = self->GetDataSize();
3779 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3780 if (size) {
3781 char* buf = new char[size];
3782 if (self->GetDataHere(buf))
3783 rval = PyString_FromStringAndSize(buf, size);
3784 delete [] buf;
3785 }
3786 if (! rval) {
3787 rval = Py_None;
3788 Py_INCREF(rval);
3789 }
3790 wxPyEndBlockThreads(blocked);
3791 return rval;
3792 }
3793 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3794 bool rval;
3795 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3796 if (PyString_Check(data)) {
3797 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3798 }
3799 else {
3800 // raise a TypeError if not a string
3801 PyErr_SetString(PyExc_TypeError, "String expected.");
3802 rval = false;
3803 }
3804 wxPyEndBlockThreads(blocked);
3805 return rval;
3806 }
3807 // Create a new class for wxPython to use
3808 class wxPyDataObjectSimple : public wxDataObjectSimple {
3809 public:
3810 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3811 : wxDataObjectSimple(format) {}
3812
3813 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3814 bool GetDataHere(void *buf) const;
3815 bool SetData(size_t len, const void *buf);
3816 PYPRIVATE;
3817 };
3818
3819 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3820
3821 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3822 // We need to get the data for this object and write it to buf. I think
3823 // the best way to do this for wxPython is to have the Python method
3824 // return either a string or None and then act appropriately with the
3825 // C++ version.
3826
3827 bool rval = false;
3828 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3829 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3830 PyObject* ro;
3831 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3832 if (ro) {
3833 rval = (ro != Py_None && PyString_Check(ro));
3834 if (rval)
3835 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3836 Py_DECREF(ro);
3837 }
3838 }
3839 wxPyEndBlockThreads(blocked);
3840 return rval;
3841 }
3842
3843 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3844 // For this one we simply need to make a string from buf and len
3845 // and send it to the Python method.
3846 bool rval = false;
3847 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3848 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3849 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3850 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3851 Py_DECREF(data);
3852 }
3853 wxPyEndBlockThreads(blocked);
3854 return rval;
3855 }
3856
3857 // Create a new class for wxPython to use
3858 class wxPyTextDataObject : public wxTextDataObject {
3859 public:
3860 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3861 : wxTextDataObject(text) {}
3862
3863 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3864 DEC_PYCALLBACK_STRING__const(GetText);
3865 DEC_PYCALLBACK__STRING(SetText);
3866 PYPRIVATE;
3867 };
3868
3869 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3870 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3871 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3872
3873
3874 // Create a new class for wxPython to use
3875 class wxPyBitmapDataObject : public wxBitmapDataObject {
3876 public:
3877 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3878 : wxBitmapDataObject(bitmap) {}
3879
3880 wxBitmap GetBitmap() const;
3881 void SetBitmap(const wxBitmap& bitmap);
3882 PYPRIVATE;
3883 };
3884
3885 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3886 wxBitmap* rval = &wxNullBitmap;
3887 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3888 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3889 PyObject* ro;
3890 wxBitmap* ptr;
3891 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3892 if (ro) {
3893 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3894 rval = ptr;
3895 Py_DECREF(ro);
3896 }
3897 }
3898 wxPyEndBlockThreads(blocked);
3899 return *rval;
3900 }
3901
3902 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3903 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3904 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3905 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3906 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3907 Py_DECREF(bo);
3908 }
3909 wxPyEndBlockThreads(blocked);
3910 }
3911
3912 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3913 return new wxCustomDataObject(wxDataFormat(formatName));
3914 }
3915 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3916 bool rval;
3917 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3918 if (PyString_Check(data)) {
3919 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3920 }
3921 else {
3922 // raise a TypeError if not a string
3923 PyErr_SetString(PyExc_TypeError, "String expected.");
3924 rval = false;
3925 }
3926 wxPyEndBlockThreads(blocked);
3927 return rval;
3928 }
3929 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3930 PyObject* obj;
3931 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3932 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3933 wxPyEndBlockThreads(blocked);
3934 return obj;
3935 }
3936
3937 #include <wx/metafile.h>
3938
3939
3940 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3941
3942
3943 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3944 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3945 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3946 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3947 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3948
3949
3950 class wxPyTextDropTarget : public wxTextDropTarget {
3951 public:
3952 wxPyTextDropTarget() {}
3953
3954 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3955
3956 DEC_PYCALLBACK__(OnLeave);
3957 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3959 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3960 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3961
3962 PYPRIVATE;
3963 };
3964
3965 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3966 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3967 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3969 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3970 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3971
3972
3973
3974 class wxPyFileDropTarget : public wxFileDropTarget {
3975 public:
3976 wxPyFileDropTarget() {}
3977
3978 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3979
3980 DEC_PYCALLBACK__(OnLeave);
3981 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3983 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3984 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3985
3986 PYPRIVATE;
3987 };
3988
3989 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3990 const wxArrayString& filenames) {
3991 bool rval = false;
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3994 PyObject* list = wxArrayString2PyList_helper(filenames);
3995 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3996 Py_DECREF(list);
3997 }
3998 wxPyEndBlockThreads(blocked);
3999 return rval;
4000 }
4001
4002
4003
4004 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4005 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4008 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4009
4010
4011
4012
4013 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4014
4015 #include <wx/display.h>
4016 #include <wx/vidmode.h>
4017
4018 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4019 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4020
4021 #if !wxUSE_DISPLAY
4022 const wxVideoMode wxDefaultVideoMode;
4023 #endif
4024
4025 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4026 #if wxUSE_DISPLAY
4027 PyObject* pyList = NULL;
4028 wxArrayVideoModes arr = self->GetModes(mode);
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 pyList = PyList_New(0);
4031 for (size_t i=0; i < arr.GetCount(); i++)
4032 {
4033 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4034 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4035 PyList_Append(pyList, pyObj);
4036 Py_DECREF(pyObj);
4037 }
4038 wxPyEndBlockThreads(blocked);
4039 return pyList;
4040 #else
4041 wxPyRaiseNotImplemented();
4042 return NULL;
4043 #endif
4044 }
4045 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4046 #if wxUSE_DISPLAY
4047 return self->GetCurrentMode();
4048 #else
4049 wxPyRaiseNotImplemented();
4050 return wxDefaultVideoMode;
4051 #endif
4052 }
4053 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4054 #if wxUSE_DISPLAY
4055 return self->ChangeMode(mode);
4056 #else
4057 wxPyRaiseNotImplemented();
4058 return false;
4059 #endif
4060 }
4061 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4062 #if wxUSE_DISPLAY
4063 self->ResetMode();
4064 #else
4065 wxPyRaiseNotImplemented();
4066 #endif
4067 }
4068
4069 #include <wx/stdpaths.h>
4070
4071 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4072 return (wxStandardPaths*) &wxStandardPaths::Get();
4073 }
4074 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4075 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4076
4077 #ifndef wxHAS_POWER_EVENTS
4078 // Dummy class and other definitions for platforms that don't have them
4079
4080 // See wxPython_int.h for wxPowerEvent
4081
4082 enum {
4083 wxEVT_POWER_SUSPENDING,
4084 wxEVT_POWER_SUSPENDED,
4085 wxEVT_POWER_SUSPEND_CANCEL,
4086 wxEVT_POWER_RESUME,
4087 };
4088
4089 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4090 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4091
4092 #endif
4093
4094
4095 #include <wx/aboutdlg.h>
4096
4097 #ifdef __cplusplus
4098 extern "C" {
4099 #endif
4100 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj = 0;
4102 wxSystemColour arg1 ;
4103 wxColour result;
4104 int val1 ;
4105 int ecode1 = 0 ;
4106 PyObject * obj0 = 0 ;
4107 char * kwnames[] = {
4108 (char *) "index", NULL
4109 };
4110
4111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4112 ecode1 = SWIG_AsVal_int(obj0, &val1);
4113 if (!SWIG_IsOK(ecode1)) {
4114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4115 }
4116 arg1 = static_cast< wxSystemColour >(val1);
4117 {
4118 if (!wxPyCheckForApp()) SWIG_fail;
4119 PyThreadState* __tstate = wxPyBeginAllowThreads();
4120 result = wxSystemSettings::GetColour(arg1);
4121 wxPyEndAllowThreads(__tstate);
4122 if (PyErr_Occurred()) SWIG_fail;
4123 }
4124 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4125 return resultobj;
4126 fail:
4127 return NULL;
4128 }
4129
4130
4131 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4132 PyObject *resultobj = 0;
4133 wxSystemFont arg1 ;
4134 wxFont result;
4135 int val1 ;
4136 int ecode1 = 0 ;
4137 PyObject * obj0 = 0 ;
4138 char * kwnames[] = {
4139 (char *) "index", NULL
4140 };
4141
4142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4143 ecode1 = SWIG_AsVal_int(obj0, &val1);
4144 if (!SWIG_IsOK(ecode1)) {
4145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4146 }
4147 arg1 = static_cast< wxSystemFont >(val1);
4148 {
4149 if (!wxPyCheckForApp()) SWIG_fail;
4150 PyThreadState* __tstate = wxPyBeginAllowThreads();
4151 result = wxSystemSettings::GetFont(arg1);
4152 wxPyEndAllowThreads(__tstate);
4153 if (PyErr_Occurred()) SWIG_fail;
4154 }
4155 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4156 return resultobj;
4157 fail:
4158 return NULL;
4159 }
4160
4161
4162 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4163 PyObject *resultobj = 0;
4164 wxSystemMetric arg1 ;
4165 wxWindow *arg2 = (wxWindow *) NULL ;
4166 int result;
4167 int val1 ;
4168 int ecode1 = 0 ;
4169 void *argp2 = 0 ;
4170 int res2 = 0 ;
4171 PyObject * obj0 = 0 ;
4172 PyObject * obj1 = 0 ;
4173 char * kwnames[] = {
4174 (char *) "index",(char *) "win", NULL
4175 };
4176
4177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4178 ecode1 = SWIG_AsVal_int(obj0, &val1);
4179 if (!SWIG_IsOK(ecode1)) {
4180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4181 }
4182 arg1 = static_cast< wxSystemMetric >(val1);
4183 if (obj1) {
4184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4185 if (!SWIG_IsOK(res2)) {
4186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4187 }
4188 arg2 = reinterpret_cast< wxWindow * >(argp2);
4189 }
4190 {
4191 if (!wxPyCheckForApp()) SWIG_fail;
4192 PyThreadState* __tstate = wxPyBeginAllowThreads();
4193 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4194 wxPyEndAllowThreads(__tstate);
4195 if (PyErr_Occurred()) SWIG_fail;
4196 }
4197 resultobj = SWIG_From_int(static_cast< int >(result));
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
4204 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4205 PyObject *resultobj = 0;
4206 wxSystemFeature arg1 ;
4207 bool result;
4208 int val1 ;
4209 int ecode1 = 0 ;
4210 PyObject * obj0 = 0 ;
4211 char * kwnames[] = {
4212 (char *) "index", NULL
4213 };
4214
4215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4216 ecode1 = SWIG_AsVal_int(obj0, &val1);
4217 if (!SWIG_IsOK(ecode1)) {
4218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4219 }
4220 arg1 = static_cast< wxSystemFeature >(val1);
4221 {
4222 if (!wxPyCheckForApp()) SWIG_fail;
4223 PyThreadState* __tstate = wxPyBeginAllowThreads();
4224 result = (bool)wxSystemSettings::HasFeature(arg1);
4225 wxPyEndAllowThreads(__tstate);
4226 if (PyErr_Occurred()) SWIG_fail;
4227 }
4228 {
4229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4230 }
4231 return resultobj;
4232 fail:
4233 return NULL;
4234 }
4235
4236
4237 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4238 PyObject *resultobj = 0;
4239 wxSystemScreenType result;
4240
4241 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4242 {
4243 if (!wxPyCheckForApp()) SWIG_fail;
4244 PyThreadState* __tstate = wxPyBeginAllowThreads();
4245 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 resultobj = SWIG_From_int(static_cast< int >(result));
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
4256 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj = 0;
4258 wxSystemScreenType arg1 ;
4259 int val1 ;
4260 int ecode1 = 0 ;
4261 PyObject * obj0 = 0 ;
4262 char * kwnames[] = {
4263 (char *) "screen", NULL
4264 };
4265
4266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4267 ecode1 = SWIG_AsVal_int(obj0, &val1);
4268 if (!SWIG_IsOK(ecode1)) {
4269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4270 }
4271 arg1 = static_cast< wxSystemScreenType >(val1);
4272 {
4273 if (!wxPyCheckForApp()) SWIG_fail;
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 wxSystemSettings::SetScreenType(arg1);
4276 wxPyEndAllowThreads(__tstate);
4277 if (PyErr_Occurred()) SWIG_fail;
4278 }
4279 resultobj = SWIG_Py_Void();
4280 return resultobj;
4281 fail:
4282 return NULL;
4283 }
4284
4285
4286 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4287 PyObject *obj;
4288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4289 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4290 return SWIG_Py_Void();
4291 }
4292
4293 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4294 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4295 return 1;
4296 }
4297
4298
4299 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4300 PyObject *pyobj = 0;
4301
4302 {
4303 #if wxUSE_UNICODE
4304 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4305 #else
4306 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4307 #endif
4308 }
4309 return pyobj;
4310 }
4311
4312
4313 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4314 PyObject *resultobj = 0;
4315 wxSystemOptions *result = 0 ;
4316
4317 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4318 {
4319 PyThreadState* __tstate = wxPyBeginAllowThreads();
4320 result = (wxSystemOptions *)new wxSystemOptions();
4321 wxPyEndAllowThreads(__tstate);
4322 if (PyErr_Occurred()) SWIG_fail;
4323 }
4324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4325 return resultobj;
4326 fail:
4327 return NULL;
4328 }
4329
4330
4331 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4332 PyObject *resultobj = 0;
4333 wxString *arg1 = 0 ;
4334 wxString *arg2 = 0 ;
4335 bool temp1 = false ;
4336 bool temp2 = false ;
4337 PyObject * obj0 = 0 ;
4338 PyObject * obj1 = 0 ;
4339 char * kwnames[] = {
4340 (char *) "name",(char *) "value", NULL
4341 };
4342
4343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4344 {
4345 arg1 = wxString_in_helper(obj0);
4346 if (arg1 == NULL) SWIG_fail;
4347 temp1 = true;
4348 }
4349 {
4350 arg2 = wxString_in_helper(obj1);
4351 if (arg2 == NULL) SWIG_fail;
4352 temp2 = true;
4353 }
4354 {
4355 PyThreadState* __tstate = wxPyBeginAllowThreads();
4356 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4357 wxPyEndAllowThreads(__tstate);
4358 if (PyErr_Occurred()) SWIG_fail;
4359 }
4360 resultobj = SWIG_Py_Void();
4361 {
4362 if (temp1)
4363 delete arg1;
4364 }
4365 {
4366 if (temp2)
4367 delete arg2;
4368 }
4369 return resultobj;
4370 fail:
4371 {
4372 if (temp1)
4373 delete arg1;
4374 }
4375 {
4376 if (temp2)
4377 delete arg2;
4378 }
4379 return NULL;
4380 }
4381
4382
4383 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4384 PyObject *resultobj = 0;
4385 wxString *arg1 = 0 ;
4386 int arg2 ;
4387 bool temp1 = false ;
4388 int val2 ;
4389 int ecode2 = 0 ;
4390 PyObject * obj0 = 0 ;
4391 PyObject * obj1 = 0 ;
4392 char * kwnames[] = {
4393 (char *) "name",(char *) "value", NULL
4394 };
4395
4396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4397 {
4398 arg1 = wxString_in_helper(obj0);
4399 if (arg1 == NULL) SWIG_fail;
4400 temp1 = true;
4401 }
4402 ecode2 = SWIG_AsVal_int(obj1, &val2);
4403 if (!SWIG_IsOK(ecode2)) {
4404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4405 }
4406 arg2 = static_cast< int >(val2);
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4410 wxPyEndAllowThreads(__tstate);
4411 if (PyErr_Occurred()) SWIG_fail;
4412 }
4413 resultobj = SWIG_Py_Void();
4414 {
4415 if (temp1)
4416 delete arg1;
4417 }
4418 return resultobj;
4419 fail:
4420 {
4421 if (temp1)
4422 delete arg1;
4423 }
4424 return NULL;
4425 }
4426
4427
4428 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4429 PyObject *resultobj = 0;
4430 wxString *arg1 = 0 ;
4431 wxString result;
4432 bool temp1 = false ;
4433 PyObject * obj0 = 0 ;
4434 char * kwnames[] = {
4435 (char *) "name", NULL
4436 };
4437
4438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4439 {
4440 arg1 = wxString_in_helper(obj0);
4441 if (arg1 == NULL) SWIG_fail;
4442 temp1 = true;
4443 }
4444 {
4445 PyThreadState* __tstate = wxPyBeginAllowThreads();
4446 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4447 wxPyEndAllowThreads(__tstate);
4448 if (PyErr_Occurred()) SWIG_fail;
4449 }
4450 {
4451 #if wxUSE_UNICODE
4452 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4453 #else
4454 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4455 #endif
4456 }
4457 {
4458 if (temp1)
4459 delete arg1;
4460 }
4461 return resultobj;
4462 fail:
4463 {
4464 if (temp1)
4465 delete arg1;
4466 }
4467 return NULL;
4468 }
4469
4470
4471 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4472 PyObject *resultobj = 0;
4473 wxString *arg1 = 0 ;
4474 int result;
4475 bool temp1 = false ;
4476 PyObject * obj0 = 0 ;
4477 char * kwnames[] = {
4478 (char *) "name", NULL
4479 };
4480
4481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4482 {
4483 arg1 = wxString_in_helper(obj0);
4484 if (arg1 == NULL) SWIG_fail;
4485 temp1 = true;
4486 }
4487 {
4488 PyThreadState* __tstate = wxPyBeginAllowThreads();
4489 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4490 wxPyEndAllowThreads(__tstate);
4491 if (PyErr_Occurred()) SWIG_fail;
4492 }
4493 resultobj = SWIG_From_int(static_cast< int >(result));
4494 {
4495 if (temp1)
4496 delete arg1;
4497 }
4498 return resultobj;
4499 fail:
4500 {
4501 if (temp1)
4502 delete arg1;
4503 }
4504 return NULL;
4505 }
4506
4507
4508 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4509 PyObject *resultobj = 0;
4510 wxString *arg1 = 0 ;
4511 bool result;
4512 bool temp1 = false ;
4513 PyObject * obj0 = 0 ;
4514 char * kwnames[] = {
4515 (char *) "name", NULL
4516 };
4517
4518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4519 {
4520 arg1 = wxString_in_helper(obj0);
4521 if (arg1 == NULL) SWIG_fail;
4522 temp1 = true;
4523 }
4524 {
4525 PyThreadState* __tstate = wxPyBeginAllowThreads();
4526 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4527 wxPyEndAllowThreads(__tstate);
4528 if (PyErr_Occurred()) SWIG_fail;
4529 }
4530 {
4531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4532 }
4533 {
4534 if (temp1)
4535 delete arg1;
4536 }
4537 return resultobj;
4538 fail:
4539 {
4540 if (temp1)
4541 delete arg1;
4542 }
4543 return NULL;
4544 }
4545
4546
4547 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4548 PyObject *resultobj = 0;
4549 wxString *arg1 = 0 ;
4550 bool result;
4551 bool temp1 = false ;
4552 PyObject * obj0 = 0 ;
4553 char * kwnames[] = {
4554 (char *) "name", NULL
4555 };
4556
4557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4558 {
4559 arg1 = wxString_in_helper(obj0);
4560 if (arg1 == NULL) SWIG_fail;
4561 temp1 = true;
4562 }
4563 {
4564 PyThreadState* __tstate = wxPyBeginAllowThreads();
4565 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4566 wxPyEndAllowThreads(__tstate);
4567 if (PyErr_Occurred()) SWIG_fail;
4568 }
4569 {
4570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4571 }
4572 {
4573 if (temp1)
4574 delete arg1;
4575 }
4576 return resultobj;
4577 fail:
4578 {
4579 if (temp1)
4580 delete arg1;
4581 }
4582 return NULL;
4583 }
4584
4585
4586 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4587 PyObject *obj;
4588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4589 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4590 return SWIG_Py_Void();
4591 }
4592
4593 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4594 return SWIG_Python_InitShadowInstance(args);
4595 }
4596
4597 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4598 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4599 return 1;
4600 }
4601
4602
4603 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4604 PyObject *pyobj = 0;
4605
4606 {
4607 #if wxUSE_UNICODE
4608 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4609 #else
4610 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4611 #endif
4612 }
4613 return pyobj;
4614 }
4615
4616
4617 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4618 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4619 return 1;
4620 }
4621
4622
4623 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4624 PyObject *pyobj = 0;
4625
4626 {
4627 #if wxUSE_UNICODE
4628 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4629 #else
4630 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4631 #endif
4632 }
4633 return pyobj;
4634 }
4635
4636
4637 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4638 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4639 return 1;
4640 }
4641
4642
4643 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4644 PyObject *pyobj = 0;
4645
4646 {
4647 #if wxUSE_UNICODE
4648 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4649 #else
4650 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4651 #endif
4652 }
4653 return pyobj;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4658 PyObject *resultobj = 0;
4659 long result;
4660
4661 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4662 {
4663 PyThreadState* __tstate = wxPyBeginAllowThreads();
4664 result = (long)wxNewId();
4665 wxPyEndAllowThreads(__tstate);
4666 if (PyErr_Occurred()) SWIG_fail;
4667 }
4668 resultobj = SWIG_From_long(static_cast< long >(result));
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 long arg1 ;
4678 long val1 ;
4679 int ecode1 = 0 ;
4680 PyObject * obj0 = 0 ;
4681 char * kwnames[] = {
4682 (char *) "id", NULL
4683 };
4684
4685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4686 ecode1 = SWIG_AsVal_long(obj0, &val1);
4687 if (!SWIG_IsOK(ecode1)) {
4688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4689 }
4690 arg1 = static_cast< long >(val1);
4691 {
4692 PyThreadState* __tstate = wxPyBeginAllowThreads();
4693 wxRegisterId(arg1);
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 resultobj = SWIG_Py_Void();
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4705 PyObject *resultobj = 0;
4706 long result;
4707
4708 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4709 {
4710 PyThreadState* __tstate = wxPyBeginAllowThreads();
4711 result = (long)wxGetCurrentId();
4712 wxPyEndAllowThreads(__tstate);
4713 if (PyErr_Occurred()) SWIG_fail;
4714 }
4715 resultobj = SWIG_From_long(static_cast< long >(result));
4716 return resultobj;
4717 fail:
4718 return NULL;
4719 }
4720
4721
4722 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4723 PyObject *resultobj = 0;
4724 int arg1 ;
4725 bool result;
4726 int val1 ;
4727 int ecode1 = 0 ;
4728 PyObject * obj0 = 0 ;
4729 char * kwnames[] = {
4730 (char *) "id", NULL
4731 };
4732
4733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4734 ecode1 = SWIG_AsVal_int(obj0, &val1);
4735 if (!SWIG_IsOK(ecode1)) {
4736 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4737 }
4738 arg1 = static_cast< int >(val1);
4739 {
4740 PyThreadState* __tstate = wxPyBeginAllowThreads();
4741 result = (bool)wxIsStockID(arg1);
4742 wxPyEndAllowThreads(__tstate);
4743 if (PyErr_Occurred()) SWIG_fail;
4744 }
4745 {
4746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4747 }
4748 return resultobj;
4749 fail:
4750 return NULL;
4751 }
4752
4753
4754 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4755 PyObject *resultobj = 0;
4756 int arg1 ;
4757 wxString *arg2 = 0 ;
4758 bool result;
4759 int val1 ;
4760 int ecode1 = 0 ;
4761 bool temp2 = false ;
4762 PyObject * obj0 = 0 ;
4763 PyObject * obj1 = 0 ;
4764 char * kwnames[] = {
4765 (char *) "id",(char *) "label", NULL
4766 };
4767
4768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4769 ecode1 = SWIG_AsVal_int(obj0, &val1);
4770 if (!SWIG_IsOK(ecode1)) {
4771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4772 }
4773 arg1 = static_cast< int >(val1);
4774 {
4775 arg2 = wxString_in_helper(obj1);
4776 if (arg2 == NULL) SWIG_fail;
4777 temp2 = true;
4778 }
4779 {
4780 PyThreadState* __tstate = wxPyBeginAllowThreads();
4781 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4782 wxPyEndAllowThreads(__tstate);
4783 if (PyErr_Occurred()) SWIG_fail;
4784 }
4785 {
4786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4787 }
4788 {
4789 if (temp2)
4790 delete arg2;
4791 }
4792 return resultobj;
4793 fail:
4794 {
4795 if (temp2)
4796 delete arg2;
4797 }
4798 return NULL;
4799 }
4800
4801
4802 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4803 PyObject *resultobj = 0;
4804 int arg1 ;
4805 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4806 wxString result;
4807 int val1 ;
4808 int ecode1 = 0 ;
4809 long val2 ;
4810 int ecode2 = 0 ;
4811 PyObject * obj0 = 0 ;
4812 PyObject * obj1 = 0 ;
4813 char * kwnames[] = {
4814 (char *) "id",(char *) "flags", NULL
4815 };
4816
4817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4818 ecode1 = SWIG_AsVal_int(obj0, &val1);
4819 if (!SWIG_IsOK(ecode1)) {
4820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4821 }
4822 arg1 = static_cast< int >(val1);
4823 if (obj1) {
4824 ecode2 = SWIG_AsVal_long(obj1, &val2);
4825 if (!SWIG_IsOK(ecode2)) {
4826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4827 }
4828 arg2 = static_cast< long >(val2);
4829 }
4830 {
4831 PyThreadState* __tstate = wxPyBeginAllowThreads();
4832 result = wxGetStockLabel(arg1,arg2);
4833 wxPyEndAllowThreads(__tstate);
4834 if (PyErr_Occurred()) SWIG_fail;
4835 }
4836 {
4837 #if wxUSE_UNICODE
4838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4839 #else
4840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4841 #endif
4842 }
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj = 0;
4851 int arg1 ;
4852 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4853 wxString result;
4854 int val1 ;
4855 int ecode1 = 0 ;
4856 int val2 ;
4857 int ecode2 = 0 ;
4858 PyObject * obj0 = 0 ;
4859 PyObject * obj1 = 0 ;
4860 char * kwnames[] = {
4861 (char *) "id",(char *) "client", NULL
4862 };
4863
4864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4865 ecode1 = SWIG_AsVal_int(obj0, &val1);
4866 if (!SWIG_IsOK(ecode1)) {
4867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4868 }
4869 arg1 = static_cast< int >(val1);
4870 if (obj1) {
4871 ecode2 = SWIG_AsVal_int(obj1, &val2);
4872 if (!SWIG_IsOK(ecode2)) {
4873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4874 }
4875 arg2 = static_cast< wxStockHelpStringClient >(val2);
4876 }
4877 {
4878 PyThreadState* __tstate = wxPyBeginAllowThreads();
4879 result = wxGetStockHelpString(arg1,arg2);
4880 wxPyEndAllowThreads(__tstate);
4881 if (PyErr_Occurred()) SWIG_fail;
4882 }
4883 {
4884 #if wxUSE_UNICODE
4885 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4886 #else
4887 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4888 #endif
4889 }
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4897 PyObject *resultobj = 0;
4898
4899 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4900 {
4901 if (!wxPyCheckForApp()) SWIG_fail;
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 wxBell();
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 resultobj = SWIG_Py_Void();
4908 return resultobj;
4909 fail:
4910 return NULL;
4911 }
4912
4913
4914 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4915 PyObject *resultobj = 0;
4916
4917 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4918 {
4919 if (!wxPyCheckForApp()) SWIG_fail;
4920 PyThreadState* __tstate = wxPyBeginAllowThreads();
4921 wxEndBusyCursor();
4922 wxPyEndAllowThreads(__tstate);
4923 if (PyErr_Occurred()) SWIG_fail;
4924 }
4925 resultobj = SWIG_Py_Void();
4926 return resultobj;
4927 fail:
4928 return NULL;
4929 }
4930
4931
4932 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4933 PyObject *resultobj = 0;
4934 bool result;
4935
4936 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4937 {
4938 PyThreadState* __tstate = wxPyBeginAllowThreads();
4939 result = (bool)wxIsBusy();
4940 wxPyEndAllowThreads(__tstate);
4941 if (PyErr_Occurred()) SWIG_fail;
4942 }
4943 {
4944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4945 }
4946 return resultobj;
4947 fail:
4948 return NULL;
4949 }
4950
4951
4952 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4953 PyObject *resultobj = 0;
4954 wxString result;
4955
4956 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4957 {
4958 PyThreadState* __tstate = wxPyBeginAllowThreads();
4959 result = wxNow();
4960 wxPyEndAllowThreads(__tstate);
4961 if (PyErr_Occurred()) SWIG_fail;
4962 }
4963 {
4964 #if wxUSE_UNICODE
4965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4966 #else
4967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4968 #endif
4969 }
4970 return resultobj;
4971 fail:
4972 return NULL;
4973 }
4974
4975
4976 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4977 PyObject *resultobj = 0;
4978 wxString const &arg1_defvalue = wxPyEmptyString ;
4979 wxString *arg1 = (wxString *) &arg1_defvalue ;
4980 bool result;
4981 bool temp1 = false ;
4982 PyObject * obj0 = 0 ;
4983 char * kwnames[] = {
4984 (char *) "command", NULL
4985 };
4986
4987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4988 if (obj0) {
4989 {
4990 arg1 = wxString_in_helper(obj0);
4991 if (arg1 == NULL) SWIG_fail;
4992 temp1 = true;
4993 }
4994 }
4995 {
4996 PyThreadState* __tstate = wxPyBeginAllowThreads();
4997 result = (bool)wxShell((wxString const &)*arg1);
4998 wxPyEndAllowThreads(__tstate);
4999 if (PyErr_Occurred()) SWIG_fail;
5000 }
5001 {
5002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5003 }
5004 {
5005 if (temp1)
5006 delete arg1;
5007 }
5008 return resultobj;
5009 fail:
5010 {
5011 if (temp1)
5012 delete arg1;
5013 }
5014 return NULL;
5015 }
5016
5017
5018 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5019 PyObject *resultobj = 0;
5020 int *arg1 = (int *) 0 ;
5021 int *arg2 = (int *) 0 ;
5022 int result;
5023 int temp1 ;
5024 int res1 = SWIG_TMPOBJ ;
5025 int temp2 ;
5026 int res2 = SWIG_TMPOBJ ;
5027
5028 arg1 = &temp1;
5029 arg2 = &temp2;
5030 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5031 {
5032 PyThreadState* __tstate = wxPyBeginAllowThreads();
5033 result = (int)wxGetOsVersion(arg1,arg2);
5034 wxPyEndAllowThreads(__tstate);
5035 if (PyErr_Occurred()) SWIG_fail;
5036 }
5037 resultobj = SWIG_From_int(static_cast< int >(result));
5038 if (SWIG_IsTmpObj(res1)) {
5039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5040 } else {
5041 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5043 }
5044 if (SWIG_IsTmpObj(res2)) {
5045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5046 } else {
5047 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5049 }
5050 return resultobj;
5051 fail:
5052 return NULL;
5053 }
5054
5055
5056 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5057 PyObject *resultobj = 0;
5058 wxString result;
5059
5060 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5061 {
5062 PyThreadState* __tstate = wxPyBeginAllowThreads();
5063 result = wxGetOsDescription();
5064 wxPyEndAllowThreads(__tstate);
5065 if (PyErr_Occurred()) SWIG_fail;
5066 }
5067 {
5068 #if wxUSE_UNICODE
5069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5070 #else
5071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5072 #endif
5073 }
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5081 PyObject *resultobj = 0;
5082 bool result;
5083
5084 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5085 {
5086 PyThreadState* __tstate = wxPyBeginAllowThreads();
5087 result = (bool)wxIsPlatformLittleEndian();
5088 wxPyEndAllowThreads(__tstate);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 {
5092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5093 }
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5101 PyObject *resultobj = 0;
5102 bool result;
5103
5104 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5105 {
5106 PyThreadState* __tstate = wxPyBeginAllowThreads();
5107 result = (bool)wxIsPlatform64Bit();
5108 wxPyEndAllowThreads(__tstate);
5109 if (PyErr_Occurred()) SWIG_fail;
5110 }
5111 {
5112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5113 }
5114 return resultobj;
5115 fail:
5116 return NULL;
5117 }
5118
5119
5120 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 PyObject *resultobj = 0;
5122 wxMemorySize result;
5123
5124 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5125 {
5126 PyThreadState* __tstate = wxPyBeginAllowThreads();
5127 result = wxGetFreeMemory();
5128 wxPyEndAllowThreads(__tstate);
5129 if (PyErr_Occurred()) SWIG_fail;
5130 }
5131 {
5132 #if wxUSE_LONGLONG
5133 resultobj = PyLong_FromLongLong((&result)->GetValue());
5134 #else
5135 resultobj = PyInt_FromLong(result);
5136 #endif
5137 }
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5145 PyObject *resultobj = 0;
5146 wxShutdownFlags arg1 ;
5147 bool result;
5148 int val1 ;
5149 int ecode1 = 0 ;
5150 PyObject * obj0 = 0 ;
5151 char * kwnames[] = {
5152 (char *) "wFlags", NULL
5153 };
5154
5155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5156 ecode1 = SWIG_AsVal_int(obj0, &val1);
5157 if (!SWIG_IsOK(ecode1)) {
5158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5159 }
5160 arg1 = static_cast< wxShutdownFlags >(val1);
5161 {
5162 if (!wxPyCheckForApp()) SWIG_fail;
5163 PyThreadState* __tstate = wxPyBeginAllowThreads();
5164 result = (bool)wxShutdown(arg1);
5165 wxPyEndAllowThreads(__tstate);
5166 if (PyErr_Occurred()) SWIG_fail;
5167 }
5168 {
5169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5170 }
5171 return resultobj;
5172 fail:
5173 return NULL;
5174 }
5175
5176
5177 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5178 PyObject *resultobj = 0;
5179 int arg1 ;
5180 int val1 ;
5181 int ecode1 = 0 ;
5182 PyObject * obj0 = 0 ;
5183 char * kwnames[] = {
5184 (char *) "secs", NULL
5185 };
5186
5187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5188 ecode1 = SWIG_AsVal_int(obj0, &val1);
5189 if (!SWIG_IsOK(ecode1)) {
5190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5191 }
5192 arg1 = static_cast< int >(val1);
5193 {
5194 PyThreadState* __tstate = wxPyBeginAllowThreads();
5195 wxSleep(arg1);
5196 wxPyEndAllowThreads(__tstate);
5197 if (PyErr_Occurred()) SWIG_fail;
5198 }
5199 resultobj = SWIG_Py_Void();
5200 return resultobj;
5201 fail:
5202 return NULL;
5203 }
5204
5205
5206 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5207 PyObject *resultobj = 0;
5208 unsigned long arg1 ;
5209 unsigned long val1 ;
5210 int ecode1 = 0 ;
5211 PyObject * obj0 = 0 ;
5212 char * kwnames[] = {
5213 (char *) "milliseconds", NULL
5214 };
5215
5216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5217 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5218 if (!SWIG_IsOK(ecode1)) {
5219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5220 }
5221 arg1 = static_cast< unsigned long >(val1);
5222 {
5223 PyThreadState* __tstate = wxPyBeginAllowThreads();
5224 wxMilliSleep(arg1);
5225 wxPyEndAllowThreads(__tstate);
5226 if (PyErr_Occurred()) SWIG_fail;
5227 }
5228 resultobj = SWIG_Py_Void();
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5236 PyObject *resultobj = 0;
5237 unsigned long arg1 ;
5238 unsigned long val1 ;
5239 int ecode1 = 0 ;
5240 PyObject * obj0 = 0 ;
5241 char * kwnames[] = {
5242 (char *) "microseconds", NULL
5243 };
5244
5245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5246 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5247 if (!SWIG_IsOK(ecode1)) {
5248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5249 }
5250 arg1 = static_cast< unsigned long >(val1);
5251 {
5252 PyThreadState* __tstate = wxPyBeginAllowThreads();
5253 wxMicroSleep(arg1);
5254 wxPyEndAllowThreads(__tstate);
5255 if (PyErr_Occurred()) SWIG_fail;
5256 }
5257 resultobj = SWIG_Py_Void();
5258 return resultobj;
5259 fail:
5260 return NULL;
5261 }
5262
5263
5264 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5265 PyObject *resultobj = 0;
5266 bool arg1 ;
5267 bool val1 ;
5268 int ecode1 = 0 ;
5269 PyObject * obj0 = 0 ;
5270 char * kwnames[] = {
5271 (char *) "enable", NULL
5272 };
5273
5274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5275 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5276 if (!SWIG_IsOK(ecode1)) {
5277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5278 }
5279 arg1 = static_cast< bool >(val1);
5280 {
5281 PyThreadState* __tstate = wxPyBeginAllowThreads();
5282 wxEnableTopLevelWindows(arg1);
5283 wxPyEndAllowThreads(__tstate);
5284 if (PyErr_Occurred()) SWIG_fail;
5285 }
5286 resultobj = SWIG_Py_Void();
5287 return resultobj;
5288 fail:
5289 return NULL;
5290 }
5291
5292
5293 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5294 PyObject *resultobj = 0;
5295 wxString *arg1 = 0 ;
5296 wxString result;
5297 bool temp1 = false ;
5298 PyObject * obj0 = 0 ;
5299 char * kwnames[] = {
5300 (char *) "in", NULL
5301 };
5302
5303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5304 {
5305 arg1 = wxString_in_helper(obj0);
5306 if (arg1 == NULL) SWIG_fail;
5307 temp1 = true;
5308 }
5309 {
5310 PyThreadState* __tstate = wxPyBeginAllowThreads();
5311 result = wxStripMenuCodes((wxString const &)*arg1);
5312 wxPyEndAllowThreads(__tstate);
5313 if (PyErr_Occurred()) SWIG_fail;
5314 }
5315 {
5316 #if wxUSE_UNICODE
5317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5318 #else
5319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5320 #endif
5321 }
5322 {
5323 if (temp1)
5324 delete arg1;
5325 }
5326 return resultobj;
5327 fail:
5328 {
5329 if (temp1)
5330 delete arg1;
5331 }
5332 return NULL;
5333 }
5334
5335
5336 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5337 PyObject *resultobj = 0;
5338 wxString result;
5339
5340 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5341 {
5342 PyThreadState* __tstate = wxPyBeginAllowThreads();
5343 result = wxGetEmailAddress();
5344 wxPyEndAllowThreads(__tstate);
5345 if (PyErr_Occurred()) SWIG_fail;
5346 }
5347 {
5348 #if wxUSE_UNICODE
5349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5350 #else
5351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5352 #endif
5353 }
5354 return resultobj;
5355 fail:
5356 return NULL;
5357 }
5358
5359
5360 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5361 PyObject *resultobj = 0;
5362 wxString result;
5363
5364 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5365 {
5366 PyThreadState* __tstate = wxPyBeginAllowThreads();
5367 result = wxGetHostName();
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 #if wxUSE_UNICODE
5373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5374 #else
5375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5376 #endif
5377 }
5378 return resultobj;
5379 fail:
5380 return NULL;
5381 }
5382
5383
5384 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385 PyObject *resultobj = 0;
5386 wxString result;
5387
5388 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5389 {
5390 PyThreadState* __tstate = wxPyBeginAllowThreads();
5391 result = wxGetFullHostName();
5392 wxPyEndAllowThreads(__tstate);
5393 if (PyErr_Occurred()) SWIG_fail;
5394 }
5395 {
5396 #if wxUSE_UNICODE
5397 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5398 #else
5399 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5400 #endif
5401 }
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5409 PyObject *resultobj = 0;
5410 wxString result;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5413 {
5414 PyThreadState* __tstate = wxPyBeginAllowThreads();
5415 result = wxGetUserId();
5416 wxPyEndAllowThreads(__tstate);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 #if wxUSE_UNICODE
5421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5422 #else
5423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5424 #endif
5425 }
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5433 PyObject *resultobj = 0;
5434 wxString result;
5435
5436 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5437 {
5438 PyThreadState* __tstate = wxPyBeginAllowThreads();
5439 result = wxGetUserName();
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 {
5444 #if wxUSE_UNICODE
5445 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5446 #else
5447 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5448 #endif
5449 }
5450 return resultobj;
5451 fail:
5452 return NULL;
5453 }
5454
5455
5456 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5457 PyObject *resultobj = 0;
5458 wxString result;
5459
5460 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5461 {
5462 PyThreadState* __tstate = wxPyBeginAllowThreads();
5463 result = wxGetHomeDir();
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 {
5468 #if wxUSE_UNICODE
5469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5470 #else
5471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5472 #endif
5473 }
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5481 PyObject *resultobj = 0;
5482 wxString const &arg1_defvalue = wxPyEmptyString ;
5483 wxString *arg1 = (wxString *) &arg1_defvalue ;
5484 wxString result;
5485 bool temp1 = false ;
5486 PyObject * obj0 = 0 ;
5487 char * kwnames[] = {
5488 (char *) "user", NULL
5489 };
5490
5491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5492 if (obj0) {
5493 {
5494 arg1 = wxString_in_helper(obj0);
5495 if (arg1 == NULL) SWIG_fail;
5496 temp1 = true;
5497 }
5498 }
5499 {
5500 PyThreadState* __tstate = wxPyBeginAllowThreads();
5501 result = wxGetUserHome((wxString const &)*arg1);
5502 wxPyEndAllowThreads(__tstate);
5503 if (PyErr_Occurred()) SWIG_fail;
5504 }
5505 {
5506 #if wxUSE_UNICODE
5507 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5508 #else
5509 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5510 #endif
5511 }
5512 {
5513 if (temp1)
5514 delete arg1;
5515 }
5516 return resultobj;
5517 fail:
5518 {
5519 if (temp1)
5520 delete arg1;
5521 }
5522 return NULL;
5523 }
5524
5525
5526 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5527 PyObject *resultobj = 0;
5528 unsigned long result;
5529
5530 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5531 {
5532 PyThreadState* __tstate = wxPyBeginAllowThreads();
5533 result = (unsigned long)wxGetProcessId();
5534 wxPyEndAllowThreads(__tstate);
5535 if (PyErr_Occurred()) SWIG_fail;
5536 }
5537 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5538 return resultobj;
5539 fail:
5540 return NULL;
5541 }
5542
5543
5544 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5545 PyObject *resultobj = 0;
5546
5547 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5548 {
5549 PyThreadState* __tstate = wxPyBeginAllowThreads();
5550 wxTrap();
5551 wxPyEndAllowThreads(__tstate);
5552 if (PyErr_Occurred()) SWIG_fail;
5553 }
5554 resultobj = SWIG_Py_Void();
5555 return resultobj;
5556 fail:
5557 return NULL;
5558 }
5559
5560
5561 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5562 PyObject *resultobj = 0;
5563 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5564 wxString *arg1 = (wxString *) &arg1_defvalue ;
5565 wxString const &arg2_defvalue = wxPyEmptyString ;
5566 wxString *arg2 = (wxString *) &arg2_defvalue ;
5567 wxString const &arg3_defvalue = wxPyEmptyString ;
5568 wxString *arg3 = (wxString *) &arg3_defvalue ;
5569 wxString const &arg4_defvalue = wxPyEmptyString ;
5570 wxString *arg4 = (wxString *) &arg4_defvalue ;
5571 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5572 wxString *arg5 = (wxString *) &arg5_defvalue ;
5573 int arg6 = (int) 0 ;
5574 wxWindow *arg7 = (wxWindow *) NULL ;
5575 int arg8 = (int) -1 ;
5576 int arg9 = (int) -1 ;
5577 wxString result;
5578 bool temp1 = false ;
5579 bool temp2 = false ;
5580 bool temp3 = false ;
5581 bool temp4 = false ;
5582 bool temp5 = false ;
5583 int val6 ;
5584 int ecode6 = 0 ;
5585 void *argp7 = 0 ;
5586 int res7 = 0 ;
5587 int val8 ;
5588 int ecode8 = 0 ;
5589 int val9 ;
5590 int ecode9 = 0 ;
5591 PyObject * obj0 = 0 ;
5592 PyObject * obj1 = 0 ;
5593 PyObject * obj2 = 0 ;
5594 PyObject * obj3 = 0 ;
5595 PyObject * obj4 = 0 ;
5596 PyObject * obj5 = 0 ;
5597 PyObject * obj6 = 0 ;
5598 PyObject * obj7 = 0 ;
5599 PyObject * obj8 = 0 ;
5600 char * kwnames[] = {
5601 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5602 };
5603
5604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5605 if (obj0) {
5606 {
5607 arg1 = wxString_in_helper(obj0);
5608 if (arg1 == NULL) SWIG_fail;
5609 temp1 = true;
5610 }
5611 }
5612 if (obj1) {
5613 {
5614 arg2 = wxString_in_helper(obj1);
5615 if (arg2 == NULL) SWIG_fail;
5616 temp2 = true;
5617 }
5618 }
5619 if (obj2) {
5620 {
5621 arg3 = wxString_in_helper(obj2);
5622 if (arg3 == NULL) SWIG_fail;
5623 temp3 = true;
5624 }
5625 }
5626 if (obj3) {
5627 {
5628 arg4 = wxString_in_helper(obj3);
5629 if (arg4 == NULL) SWIG_fail;
5630 temp4 = true;
5631 }
5632 }
5633 if (obj4) {
5634 {
5635 arg5 = wxString_in_helper(obj4);
5636 if (arg5 == NULL) SWIG_fail;
5637 temp5 = true;
5638 }
5639 }
5640 if (obj5) {
5641 ecode6 = SWIG_AsVal_int(obj5, &val6);
5642 if (!SWIG_IsOK(ecode6)) {
5643 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5644 }
5645 arg6 = static_cast< int >(val6);
5646 }
5647 if (obj6) {
5648 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5649 if (!SWIG_IsOK(res7)) {
5650 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5651 }
5652 arg7 = reinterpret_cast< wxWindow * >(argp7);
5653 }
5654 if (obj7) {
5655 ecode8 = SWIG_AsVal_int(obj7, &val8);
5656 if (!SWIG_IsOK(ecode8)) {
5657 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5658 }
5659 arg8 = static_cast< int >(val8);
5660 }
5661 if (obj8) {
5662 ecode9 = SWIG_AsVal_int(obj8, &val9);
5663 if (!SWIG_IsOK(ecode9)) {
5664 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5665 }
5666 arg9 = static_cast< int >(val9);
5667 }
5668 {
5669 if (!wxPyCheckForApp()) SWIG_fail;
5670 PyThreadState* __tstate = wxPyBeginAllowThreads();
5671 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5672 wxPyEndAllowThreads(__tstate);
5673 if (PyErr_Occurred()) SWIG_fail;
5674 }
5675 {
5676 #if wxUSE_UNICODE
5677 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5678 #else
5679 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5680 #endif
5681 }
5682 {
5683 if (temp1)
5684 delete arg1;
5685 }
5686 {
5687 if (temp2)
5688 delete arg2;
5689 }
5690 {
5691 if (temp3)
5692 delete arg3;
5693 }
5694 {
5695 if (temp4)
5696 delete arg4;
5697 }
5698 {
5699 if (temp5)
5700 delete arg5;
5701 }
5702 return resultobj;
5703 fail:
5704 {
5705 if (temp1)
5706 delete arg1;
5707 }
5708 {
5709 if (temp2)
5710 delete arg2;
5711 }
5712 {
5713 if (temp3)
5714 delete arg3;
5715 }
5716 {
5717 if (temp4)
5718 delete arg4;
5719 }
5720 {
5721 if (temp5)
5722 delete arg5;
5723 }
5724 return NULL;
5725 }
5726
5727
5728 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5729 PyObject *resultobj = 0;
5730 wxString *arg1 = 0 ;
5731 wxString *arg2 = 0 ;
5732 wxString const &arg3_defvalue = wxPyEmptyString ;
5733 wxString *arg3 = (wxString *) &arg3_defvalue ;
5734 wxWindow *arg4 = (wxWindow *) NULL ;
5735 wxString result;
5736 bool temp1 = false ;
5737 bool temp2 = false ;
5738 bool temp3 = false ;
5739 void *argp4 = 0 ;
5740 int res4 = 0 ;
5741 PyObject * obj0 = 0 ;
5742 PyObject * obj1 = 0 ;
5743 PyObject * obj2 = 0 ;
5744 PyObject * obj3 = 0 ;
5745 char * kwnames[] = {
5746 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5747 };
5748
5749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5750 {
5751 arg1 = wxString_in_helper(obj0);
5752 if (arg1 == NULL) SWIG_fail;
5753 temp1 = true;
5754 }
5755 {
5756 arg2 = wxString_in_helper(obj1);
5757 if (arg2 == NULL) SWIG_fail;
5758 temp2 = true;
5759 }
5760 if (obj2) {
5761 {
5762 arg3 = wxString_in_helper(obj2);
5763 if (arg3 == NULL) SWIG_fail;
5764 temp3 = true;
5765 }
5766 }
5767 if (obj3) {
5768 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5769 if (!SWIG_IsOK(res4)) {
5770 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5771 }
5772 arg4 = reinterpret_cast< wxWindow * >(argp4);
5773 }
5774 {
5775 if (!wxPyCheckForApp()) SWIG_fail;
5776 PyThreadState* __tstate = wxPyBeginAllowThreads();
5777 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5778 wxPyEndAllowThreads(__tstate);
5779 if (PyErr_Occurred()) SWIG_fail;
5780 }
5781 {
5782 #if wxUSE_UNICODE
5783 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5784 #else
5785 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5786 #endif
5787 }
5788 {
5789 if (temp1)
5790 delete arg1;
5791 }
5792 {
5793 if (temp2)
5794 delete arg2;
5795 }
5796 {
5797 if (temp3)
5798 delete arg3;
5799 }
5800 return resultobj;
5801 fail:
5802 {
5803 if (temp1)
5804 delete arg1;
5805 }
5806 {
5807 if (temp2)
5808 delete arg2;
5809 }
5810 {
5811 if (temp3)
5812 delete arg3;
5813 }
5814 return NULL;
5815 }
5816
5817
5818 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5819 PyObject *resultobj = 0;
5820 wxString *arg1 = 0 ;
5821 wxString *arg2 = 0 ;
5822 wxString const &arg3_defvalue = wxPyEmptyString ;
5823 wxString *arg3 = (wxString *) &arg3_defvalue ;
5824 wxWindow *arg4 = (wxWindow *) NULL ;
5825 wxString result;
5826 bool temp1 = false ;
5827 bool temp2 = false ;
5828 bool temp3 = false ;
5829 void *argp4 = 0 ;
5830 int res4 = 0 ;
5831 PyObject * obj0 = 0 ;
5832 PyObject * obj1 = 0 ;
5833 PyObject * obj2 = 0 ;
5834 PyObject * obj3 = 0 ;
5835 char * kwnames[] = {
5836 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5837 };
5838
5839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5840 {
5841 arg1 = wxString_in_helper(obj0);
5842 if (arg1 == NULL) SWIG_fail;
5843 temp1 = true;
5844 }
5845 {
5846 arg2 = wxString_in_helper(obj1);
5847 if (arg2 == NULL) SWIG_fail;
5848 temp2 = true;
5849 }
5850 if (obj2) {
5851 {
5852 arg3 = wxString_in_helper(obj2);
5853 if (arg3 == NULL) SWIG_fail;
5854 temp3 = true;
5855 }
5856 }
5857 if (obj3) {
5858 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5859 if (!SWIG_IsOK(res4)) {
5860 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5861 }
5862 arg4 = reinterpret_cast< wxWindow * >(argp4);
5863 }
5864 {
5865 if (!wxPyCheckForApp()) SWIG_fail;
5866 PyThreadState* __tstate = wxPyBeginAllowThreads();
5867 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5868 wxPyEndAllowThreads(__tstate);
5869 if (PyErr_Occurred()) SWIG_fail;
5870 }
5871 {
5872 #if wxUSE_UNICODE
5873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5874 #else
5875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5876 #endif
5877 }
5878 {
5879 if (temp1)
5880 delete arg1;
5881 }
5882 {
5883 if (temp2)
5884 delete arg2;
5885 }
5886 {
5887 if (temp3)
5888 delete arg3;
5889 }
5890 return resultobj;
5891 fail:
5892 {
5893 if (temp1)
5894 delete arg1;
5895 }
5896 {
5897 if (temp2)
5898 delete arg2;
5899 }
5900 {
5901 if (temp3)
5902 delete arg3;
5903 }
5904 return NULL;
5905 }
5906
5907
5908 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5909 PyObject *resultobj = 0;
5910 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5911 wxString *arg1 = (wxString *) &arg1_defvalue ;
5912 wxString const &arg2_defvalue = wxPyEmptyString ;
5913 wxString *arg2 = (wxString *) &arg2_defvalue ;
5914 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5915 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5916 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5917 wxWindow *arg5 = (wxWindow *) NULL ;
5918 wxString result;
5919 bool temp1 = false ;
5920 bool temp2 = false ;
5921 long val3 ;
5922 int ecode3 = 0 ;
5923 wxPoint temp4 ;
5924 void *argp5 = 0 ;
5925 int res5 = 0 ;
5926 PyObject * obj0 = 0 ;
5927 PyObject * obj1 = 0 ;
5928 PyObject * obj2 = 0 ;
5929 PyObject * obj3 = 0 ;
5930 PyObject * obj4 = 0 ;
5931 char * kwnames[] = {
5932 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5933 };
5934
5935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5936 if (obj0) {
5937 {
5938 arg1 = wxString_in_helper(obj0);
5939 if (arg1 == NULL) SWIG_fail;
5940 temp1 = true;
5941 }
5942 }
5943 if (obj1) {
5944 {
5945 arg2 = wxString_in_helper(obj1);
5946 if (arg2 == NULL) SWIG_fail;
5947 temp2 = true;
5948 }
5949 }
5950 if (obj2) {
5951 ecode3 = SWIG_AsVal_long(obj2, &val3);
5952 if (!SWIG_IsOK(ecode3)) {
5953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5954 }
5955 arg3 = static_cast< long >(val3);
5956 }
5957 if (obj3) {
5958 {
5959 arg4 = &temp4;
5960 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5961 }
5962 }
5963 if (obj4) {
5964 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5965 if (!SWIG_IsOK(res5)) {
5966 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5967 }
5968 arg5 = reinterpret_cast< wxWindow * >(argp5);
5969 }
5970 {
5971 if (!wxPyCheckForApp()) SWIG_fail;
5972 PyThreadState* __tstate = wxPyBeginAllowThreads();
5973 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5974 wxPyEndAllowThreads(__tstate);
5975 if (PyErr_Occurred()) SWIG_fail;
5976 }
5977 {
5978 #if wxUSE_UNICODE
5979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5980 #else
5981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5982 #endif
5983 }
5984 {
5985 if (temp1)
5986 delete arg1;
5987 }
5988 {
5989 if (temp2)
5990 delete arg2;
5991 }
5992 return resultobj;
5993 fail:
5994 {
5995 if (temp1)
5996 delete arg1;
5997 }
5998 {
5999 if (temp2)
6000 delete arg2;
6001 }
6002 return NULL;
6003 }
6004
6005
6006 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6007 PyObject *resultobj = 0;
6008 wxString *arg1 = 0 ;
6009 wxString const &arg2_defvalue = wxPyEmptyString ;
6010 wxString *arg2 = (wxString *) &arg2_defvalue ;
6011 wxString const &arg3_defvalue = wxPyEmptyString ;
6012 wxString *arg3 = (wxString *) &arg3_defvalue ;
6013 wxWindow *arg4 = (wxWindow *) NULL ;
6014 int arg5 = (int) -1 ;
6015 int arg6 = (int) -1 ;
6016 bool arg7 = (bool) true ;
6017 wxString result;
6018 bool temp1 = false ;
6019 bool temp2 = false ;
6020 bool temp3 = false ;
6021 void *argp4 = 0 ;
6022 int res4 = 0 ;
6023 int val5 ;
6024 int ecode5 = 0 ;
6025 int val6 ;
6026 int ecode6 = 0 ;
6027 bool val7 ;
6028 int ecode7 = 0 ;
6029 PyObject * obj0 = 0 ;
6030 PyObject * obj1 = 0 ;
6031 PyObject * obj2 = 0 ;
6032 PyObject * obj3 = 0 ;
6033 PyObject * obj4 = 0 ;
6034 PyObject * obj5 = 0 ;
6035 PyObject * obj6 = 0 ;
6036 char * kwnames[] = {
6037 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6038 };
6039
6040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6041 {
6042 arg1 = wxString_in_helper(obj0);
6043 if (arg1 == NULL) SWIG_fail;
6044 temp1 = true;
6045 }
6046 if (obj1) {
6047 {
6048 arg2 = wxString_in_helper(obj1);
6049 if (arg2 == NULL) SWIG_fail;
6050 temp2 = true;
6051 }
6052 }
6053 if (obj2) {
6054 {
6055 arg3 = wxString_in_helper(obj2);
6056 if (arg3 == NULL) SWIG_fail;
6057 temp3 = true;
6058 }
6059 }
6060 if (obj3) {
6061 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6062 if (!SWIG_IsOK(res4)) {
6063 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6064 }
6065 arg4 = reinterpret_cast< wxWindow * >(argp4);
6066 }
6067 if (obj4) {
6068 ecode5 = SWIG_AsVal_int(obj4, &val5);
6069 if (!SWIG_IsOK(ecode5)) {
6070 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6071 }
6072 arg5 = static_cast< int >(val5);
6073 }
6074 if (obj5) {
6075 ecode6 = SWIG_AsVal_int(obj5, &val6);
6076 if (!SWIG_IsOK(ecode6)) {
6077 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6078 }
6079 arg6 = static_cast< int >(val6);
6080 }
6081 if (obj6) {
6082 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6083 if (!SWIG_IsOK(ecode7)) {
6084 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6085 }
6086 arg7 = static_cast< bool >(val7);
6087 }
6088 {
6089 if (!wxPyCheckForApp()) SWIG_fail;
6090 PyThreadState* __tstate = wxPyBeginAllowThreads();
6091 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6092 wxPyEndAllowThreads(__tstate);
6093 if (PyErr_Occurred()) SWIG_fail;
6094 }
6095 {
6096 #if wxUSE_UNICODE
6097 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6098 #else
6099 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6100 #endif
6101 }
6102 {
6103 if (temp1)
6104 delete arg1;
6105 }
6106 {
6107 if (temp2)
6108 delete arg2;
6109 }
6110 {
6111 if (temp3)
6112 delete arg3;
6113 }
6114 return resultobj;
6115 fail:
6116 {
6117 if (temp1)
6118 delete arg1;
6119 }
6120 {
6121 if (temp2)
6122 delete arg2;
6123 }
6124 {
6125 if (temp3)
6126 delete arg3;
6127 }
6128 return NULL;
6129 }
6130
6131
6132 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj = 0;
6134 wxString *arg1 = 0 ;
6135 wxString const &arg2_defvalue = wxPyEmptyString ;
6136 wxString *arg2 = (wxString *) &arg2_defvalue ;
6137 wxString const &arg3_defvalue = wxPyEmptyString ;
6138 wxString *arg3 = (wxString *) &arg3_defvalue ;
6139 wxWindow *arg4 = (wxWindow *) NULL ;
6140 wxString result;
6141 bool temp1 = false ;
6142 bool temp2 = false ;
6143 bool temp3 = false ;
6144 void *argp4 = 0 ;
6145 int res4 = 0 ;
6146 PyObject * obj0 = 0 ;
6147 PyObject * obj1 = 0 ;
6148 PyObject * obj2 = 0 ;
6149 PyObject * obj3 = 0 ;
6150 char * kwnames[] = {
6151 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6152 };
6153
6154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6155 {
6156 arg1 = wxString_in_helper(obj0);
6157 if (arg1 == NULL) SWIG_fail;
6158 temp1 = true;
6159 }
6160 if (obj1) {
6161 {
6162 arg2 = wxString_in_helper(obj1);
6163 if (arg2 == NULL) SWIG_fail;
6164 temp2 = true;
6165 }
6166 }
6167 if (obj2) {
6168 {
6169 arg3 = wxString_in_helper(obj2);
6170 if (arg3 == NULL) SWIG_fail;
6171 temp3 = true;
6172 }
6173 }
6174 if (obj3) {
6175 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6176 if (!SWIG_IsOK(res4)) {
6177 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6178 }
6179 arg4 = reinterpret_cast< wxWindow * >(argp4);
6180 }
6181 {
6182 if (!wxPyCheckForApp()) SWIG_fail;
6183 PyThreadState* __tstate = wxPyBeginAllowThreads();
6184 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6185 wxPyEndAllowThreads(__tstate);
6186 if (PyErr_Occurred()) SWIG_fail;
6187 }
6188 {
6189 #if wxUSE_UNICODE
6190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6191 #else
6192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6193 #endif
6194 }
6195 {
6196 if (temp1)
6197 delete arg1;
6198 }
6199 {
6200 if (temp2)
6201 delete arg2;
6202 }
6203 {
6204 if (temp3)
6205 delete arg3;
6206 }
6207 return resultobj;
6208 fail:
6209 {
6210 if (temp1)
6211 delete arg1;
6212 }
6213 {
6214 if (temp2)
6215 delete arg2;
6216 }
6217 {
6218 if (temp3)
6219 delete arg3;
6220 }
6221 return NULL;
6222 }
6223
6224
6225 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6226 PyObject *resultobj = 0;
6227 wxString *arg1 = 0 ;
6228 wxString *arg2 = 0 ;
6229 int arg3 ;
6230 wxString *arg4 = (wxString *) 0 ;
6231 wxWindow *arg5 = (wxWindow *) NULL ;
6232 int arg6 = (int) -1 ;
6233 int arg7 = (int) -1 ;
6234 bool arg8 = (bool) true ;
6235 int arg9 = (int) 150 ;
6236 int arg10 = (int) 200 ;
6237 wxString result;
6238 bool temp1 = false ;
6239 bool temp2 = false ;
6240 void *argp5 = 0 ;
6241 int res5 = 0 ;
6242 int val6 ;
6243 int ecode6 = 0 ;
6244 int val7 ;
6245 int ecode7 = 0 ;
6246 bool val8 ;
6247 int ecode8 = 0 ;
6248 int val9 ;
6249 int ecode9 = 0 ;
6250 int val10 ;
6251 int ecode10 = 0 ;
6252 PyObject * obj0 = 0 ;
6253 PyObject * obj1 = 0 ;
6254 PyObject * obj2 = 0 ;
6255 PyObject * obj3 = 0 ;
6256 PyObject * obj4 = 0 ;
6257 PyObject * obj5 = 0 ;
6258 PyObject * obj6 = 0 ;
6259 PyObject * obj7 = 0 ;
6260 PyObject * obj8 = 0 ;
6261 char * kwnames[] = {
6262 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6263 };
6264
6265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6266 {
6267 arg1 = wxString_in_helper(obj0);
6268 if (arg1 == NULL) SWIG_fail;
6269 temp1 = true;
6270 }
6271 {
6272 arg2 = wxString_in_helper(obj1);
6273 if (arg2 == NULL) SWIG_fail;
6274 temp2 = true;
6275 }
6276 {
6277 arg3 = PyList_Size(obj2);
6278 arg4 = wxString_LIST_helper(obj2);
6279 if (arg4 == NULL) SWIG_fail;
6280 }
6281 if (obj3) {
6282 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6283 if (!SWIG_IsOK(res5)) {
6284 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6285 }
6286 arg5 = reinterpret_cast< wxWindow * >(argp5);
6287 }
6288 if (obj4) {
6289 ecode6 = SWIG_AsVal_int(obj4, &val6);
6290 if (!SWIG_IsOK(ecode6)) {
6291 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6292 }
6293 arg6 = static_cast< int >(val6);
6294 }
6295 if (obj5) {
6296 ecode7 = SWIG_AsVal_int(obj5, &val7);
6297 if (!SWIG_IsOK(ecode7)) {
6298 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6299 }
6300 arg7 = static_cast< int >(val7);
6301 }
6302 if (obj6) {
6303 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6304 if (!SWIG_IsOK(ecode8)) {
6305 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6306 }
6307 arg8 = static_cast< bool >(val8);
6308 }
6309 if (obj7) {
6310 ecode9 = SWIG_AsVal_int(obj7, &val9);
6311 if (!SWIG_IsOK(ecode9)) {
6312 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6313 }
6314 arg9 = static_cast< int >(val9);
6315 }
6316 if (obj8) {
6317 ecode10 = SWIG_AsVal_int(obj8, &val10);
6318 if (!SWIG_IsOK(ecode10)) {
6319 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6320 }
6321 arg10 = static_cast< int >(val10);
6322 }
6323 {
6324 if (!wxPyCheckForApp()) SWIG_fail;
6325 PyThreadState* __tstate = wxPyBeginAllowThreads();
6326 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6327 wxPyEndAllowThreads(__tstate);
6328 if (PyErr_Occurred()) SWIG_fail;
6329 }
6330 {
6331 #if wxUSE_UNICODE
6332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6333 #else
6334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6335 #endif
6336 }
6337 {
6338 if (temp1)
6339 delete arg1;
6340 }
6341 {
6342 if (temp2)
6343 delete arg2;
6344 }
6345 {
6346 if (arg4) delete [] arg4;
6347 }
6348 return resultobj;
6349 fail:
6350 {
6351 if (temp1)
6352 delete arg1;
6353 }
6354 {
6355 if (temp2)
6356 delete arg2;
6357 }
6358 {
6359 if (arg4) delete [] arg4;
6360 }
6361 return NULL;
6362 }
6363
6364
6365 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6366 PyObject *resultobj = 0;
6367 wxString *arg1 = 0 ;
6368 wxString *arg2 = 0 ;
6369 int arg3 ;
6370 wxString *arg4 = (wxString *) 0 ;
6371 wxWindow *arg5 = (wxWindow *) NULL ;
6372 int arg6 = (int) -1 ;
6373 int arg7 = (int) -1 ;
6374 bool arg8 = (bool) true ;
6375 int arg9 = (int) 150 ;
6376 int arg10 = (int) 200 ;
6377 int result;
6378 bool temp1 = false ;
6379 bool temp2 = false ;
6380 void *argp5 = 0 ;
6381 int res5 = 0 ;
6382 int val6 ;
6383 int ecode6 = 0 ;
6384 int val7 ;
6385 int ecode7 = 0 ;
6386 bool val8 ;
6387 int ecode8 = 0 ;
6388 int val9 ;
6389 int ecode9 = 0 ;
6390 int val10 ;
6391 int ecode10 = 0 ;
6392 PyObject * obj0 = 0 ;
6393 PyObject * obj1 = 0 ;
6394 PyObject * obj2 = 0 ;
6395 PyObject * obj3 = 0 ;
6396 PyObject * obj4 = 0 ;
6397 PyObject * obj5 = 0 ;
6398 PyObject * obj6 = 0 ;
6399 PyObject * obj7 = 0 ;
6400 PyObject * obj8 = 0 ;
6401 char * kwnames[] = {
6402 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6403 };
6404
6405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6406 {
6407 arg1 = wxString_in_helper(obj0);
6408 if (arg1 == NULL) SWIG_fail;
6409 temp1 = true;
6410 }
6411 {
6412 arg2 = wxString_in_helper(obj1);
6413 if (arg2 == NULL) SWIG_fail;
6414 temp2 = true;
6415 }
6416 {
6417 arg3 = PyList_Size(obj2);
6418 arg4 = wxString_LIST_helper(obj2);
6419 if (arg4 == NULL) SWIG_fail;
6420 }
6421 if (obj3) {
6422 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6423 if (!SWIG_IsOK(res5)) {
6424 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6425 }
6426 arg5 = reinterpret_cast< wxWindow * >(argp5);
6427 }
6428 if (obj4) {
6429 ecode6 = SWIG_AsVal_int(obj4, &val6);
6430 if (!SWIG_IsOK(ecode6)) {
6431 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6432 }
6433 arg6 = static_cast< int >(val6);
6434 }
6435 if (obj5) {
6436 ecode7 = SWIG_AsVal_int(obj5, &val7);
6437 if (!SWIG_IsOK(ecode7)) {
6438 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6439 }
6440 arg7 = static_cast< int >(val7);
6441 }
6442 if (obj6) {
6443 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6444 if (!SWIG_IsOK(ecode8)) {
6445 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6446 }
6447 arg8 = static_cast< bool >(val8);
6448 }
6449 if (obj7) {
6450 ecode9 = SWIG_AsVal_int(obj7, &val9);
6451 if (!SWIG_IsOK(ecode9)) {
6452 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6453 }
6454 arg9 = static_cast< int >(val9);
6455 }
6456 if (obj8) {
6457 ecode10 = SWIG_AsVal_int(obj8, &val10);
6458 if (!SWIG_IsOK(ecode10)) {
6459 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6460 }
6461 arg10 = static_cast< int >(val10);
6462 }
6463 {
6464 if (!wxPyCheckForApp()) SWIG_fail;
6465 PyThreadState* __tstate = wxPyBeginAllowThreads();
6466 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6467 wxPyEndAllowThreads(__tstate);
6468 if (PyErr_Occurred()) SWIG_fail;
6469 }
6470 resultobj = SWIG_From_int(static_cast< int >(result));
6471 {
6472 if (temp1)
6473 delete arg1;
6474 }
6475 {
6476 if (temp2)
6477 delete arg2;
6478 }
6479 {
6480 if (arg4) delete [] arg4;
6481 }
6482 return resultobj;
6483 fail:
6484 {
6485 if (temp1)
6486 delete arg1;
6487 }
6488 {
6489 if (temp2)
6490 delete arg2;
6491 }
6492 {
6493 if (arg4) delete [] arg4;
6494 }
6495 return NULL;
6496 }
6497
6498
6499 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6500 PyObject *resultobj = 0;
6501 wxString *arg1 = 0 ;
6502 wxString const &arg2_defvalue = wxPyEmptyString ;
6503 wxString *arg2 = (wxString *) &arg2_defvalue ;
6504 int arg3 = (int) wxOK|wxCENTRE ;
6505 wxWindow *arg4 = (wxWindow *) NULL ;
6506 int arg5 = (int) -1 ;
6507 int arg6 = (int) -1 ;
6508 int result;
6509 bool temp1 = false ;
6510 bool temp2 = false ;
6511 int val3 ;
6512 int ecode3 = 0 ;
6513 void *argp4 = 0 ;
6514 int res4 = 0 ;
6515 int val5 ;
6516 int ecode5 = 0 ;
6517 int val6 ;
6518 int ecode6 = 0 ;
6519 PyObject * obj0 = 0 ;
6520 PyObject * obj1 = 0 ;
6521 PyObject * obj2 = 0 ;
6522 PyObject * obj3 = 0 ;
6523 PyObject * obj4 = 0 ;
6524 PyObject * obj5 = 0 ;
6525 char * kwnames[] = {
6526 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6527 };
6528
6529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6530 {
6531 arg1 = wxString_in_helper(obj0);
6532 if (arg1 == NULL) SWIG_fail;
6533 temp1 = true;
6534 }
6535 if (obj1) {
6536 {
6537 arg2 = wxString_in_helper(obj1);
6538 if (arg2 == NULL) SWIG_fail;
6539 temp2 = true;
6540 }
6541 }
6542 if (obj2) {
6543 ecode3 = SWIG_AsVal_int(obj2, &val3);
6544 if (!SWIG_IsOK(ecode3)) {
6545 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6546 }
6547 arg3 = static_cast< int >(val3);
6548 }
6549 if (obj3) {
6550 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6551 if (!SWIG_IsOK(res4)) {
6552 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6553 }
6554 arg4 = reinterpret_cast< wxWindow * >(argp4);
6555 }
6556 if (obj4) {
6557 ecode5 = SWIG_AsVal_int(obj4, &val5);
6558 if (!SWIG_IsOK(ecode5)) {
6559 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6560 }
6561 arg5 = static_cast< int >(val5);
6562 }
6563 if (obj5) {
6564 ecode6 = SWIG_AsVal_int(obj5, &val6);
6565 if (!SWIG_IsOK(ecode6)) {
6566 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6567 }
6568 arg6 = static_cast< int >(val6);
6569 }
6570 {
6571 if (!wxPyCheckForApp()) SWIG_fail;
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6574 wxPyEndAllowThreads(__tstate);
6575 if (PyErr_Occurred()) SWIG_fail;
6576 }
6577 resultobj = SWIG_From_int(static_cast< int >(result));
6578 {
6579 if (temp1)
6580 delete arg1;
6581 }
6582 {
6583 if (temp2)
6584 delete arg2;
6585 }
6586 return resultobj;
6587 fail:
6588 {
6589 if (temp1)
6590 delete arg1;
6591 }
6592 {
6593 if (temp2)
6594 delete arg2;
6595 }
6596 return NULL;
6597 }
6598
6599
6600 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj = 0;
6602 wxString *arg1 = 0 ;
6603 wxString *arg2 = 0 ;
6604 wxString *arg3 = 0 ;
6605 long arg4 ;
6606 long arg5 = (long) 0 ;
6607 long arg6 = (long) 100 ;
6608 wxWindow *arg7 = (wxWindow *) NULL ;
6609 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6610 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6611 long result;
6612 bool temp1 = false ;
6613 bool temp2 = false ;
6614 bool temp3 = false ;
6615 long val4 ;
6616 int ecode4 = 0 ;
6617 long val5 ;
6618 int ecode5 = 0 ;
6619 long val6 ;
6620 int ecode6 = 0 ;
6621 void *argp7 = 0 ;
6622 int res7 = 0 ;
6623 wxPoint temp8 ;
6624 PyObject * obj0 = 0 ;
6625 PyObject * obj1 = 0 ;
6626 PyObject * obj2 = 0 ;
6627 PyObject * obj3 = 0 ;
6628 PyObject * obj4 = 0 ;
6629 PyObject * obj5 = 0 ;
6630 PyObject * obj6 = 0 ;
6631 PyObject * obj7 = 0 ;
6632 char * kwnames[] = {
6633 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6634 };
6635
6636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6637 {
6638 arg1 = wxString_in_helper(obj0);
6639 if (arg1 == NULL) SWIG_fail;
6640 temp1 = true;
6641 }
6642 {
6643 arg2 = wxString_in_helper(obj1);
6644 if (arg2 == NULL) SWIG_fail;
6645 temp2 = true;
6646 }
6647 {
6648 arg3 = wxString_in_helper(obj2);
6649 if (arg3 == NULL) SWIG_fail;
6650 temp3 = true;
6651 }
6652 ecode4 = SWIG_AsVal_long(obj3, &val4);
6653 if (!SWIG_IsOK(ecode4)) {
6654 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6655 }
6656 arg4 = static_cast< long >(val4);
6657 if (obj4) {
6658 ecode5 = SWIG_AsVal_long(obj4, &val5);
6659 if (!SWIG_IsOK(ecode5)) {
6660 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6661 }
6662 arg5 = static_cast< long >(val5);
6663 }
6664 if (obj5) {
6665 ecode6 = SWIG_AsVal_long(obj5, &val6);
6666 if (!SWIG_IsOK(ecode6)) {
6667 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6668 }
6669 arg6 = static_cast< long >(val6);
6670 }
6671 if (obj6) {
6672 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6673 if (!SWIG_IsOK(res7)) {
6674 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6675 }
6676 arg7 = reinterpret_cast< wxWindow * >(argp7);
6677 }
6678 if (obj7) {
6679 {
6680 arg8 = &temp8;
6681 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6682 }
6683 }
6684 {
6685 if (!wxPyCheckForApp()) SWIG_fail;
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 resultobj = SWIG_From_long(static_cast< long >(result));
6692 {
6693 if (temp1)
6694 delete arg1;
6695 }
6696 {
6697 if (temp2)
6698 delete arg2;
6699 }
6700 {
6701 if (temp3)
6702 delete arg3;
6703 }
6704 return resultobj;
6705 fail:
6706 {
6707 if (temp1)
6708 delete arg1;
6709 }
6710 {
6711 if (temp2)
6712 delete arg2;
6713 }
6714 {
6715 if (temp3)
6716 delete arg3;
6717 }
6718 return NULL;
6719 }
6720
6721
6722 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6723 PyObject *resultobj = 0;
6724 bool result;
6725
6726 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6727 {
6728 if (!wxPyCheckForApp()) SWIG_fail;
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 result = (bool)wxColourDisplay();
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 {
6735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6736 }
6737 return resultobj;
6738 fail:
6739 return NULL;
6740 }
6741
6742
6743 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6744 PyObject *resultobj = 0;
6745 int result;
6746
6747 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6748 {
6749 if (!wxPyCheckForApp()) SWIG_fail;
6750 PyThreadState* __tstate = wxPyBeginAllowThreads();
6751 result = (int)wxDisplayDepth();
6752 wxPyEndAllowThreads(__tstate);
6753 if (PyErr_Occurred()) SWIG_fail;
6754 }
6755 resultobj = SWIG_From_int(static_cast< int >(result));
6756 return resultobj;
6757 fail:
6758 return NULL;
6759 }
6760
6761
6762 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6763 PyObject *resultobj = 0;
6764 int result;
6765
6766 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6767 {
6768 if (!wxPyCheckForApp()) SWIG_fail;
6769 PyThreadState* __tstate = wxPyBeginAllowThreads();
6770 result = (int)wxGetDisplayDepth();
6771 wxPyEndAllowThreads(__tstate);
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 resultobj = SWIG_From_int(static_cast< int >(result));
6775 return resultobj;
6776 fail:
6777 return NULL;
6778 }
6779
6780
6781 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6782 PyObject *resultobj = 0;
6783 int *arg1 = (int *) 0 ;
6784 int *arg2 = (int *) 0 ;
6785 int temp1 ;
6786 int res1 = SWIG_TMPOBJ ;
6787 int temp2 ;
6788 int res2 = SWIG_TMPOBJ ;
6789
6790 arg1 = &temp1;
6791 arg2 = &temp2;
6792 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6793 {
6794 if (!wxPyCheckForApp()) SWIG_fail;
6795 PyThreadState* __tstate = wxPyBeginAllowThreads();
6796 wxDisplaySize(arg1,arg2);
6797 wxPyEndAllowThreads(__tstate);
6798 if (PyErr_Occurred()) SWIG_fail;
6799 }
6800 resultobj = SWIG_Py_Void();
6801 if (SWIG_IsTmpObj(res1)) {
6802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6803 } else {
6804 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6806 }
6807 if (SWIG_IsTmpObj(res2)) {
6808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6809 } else {
6810 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6812 }
6813 return resultobj;
6814 fail:
6815 return NULL;
6816 }
6817
6818
6819 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6820 PyObject *resultobj = 0;
6821 wxSize result;
6822
6823 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6824 {
6825 if (!wxPyCheckForApp()) SWIG_fail;
6826 PyThreadState* __tstate = wxPyBeginAllowThreads();
6827 result = wxGetDisplaySize();
6828 wxPyEndAllowThreads(__tstate);
6829 if (PyErr_Occurred()) SWIG_fail;
6830 }
6831 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6832 return resultobj;
6833 fail:
6834 return NULL;
6835 }
6836
6837
6838 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6839 PyObject *resultobj = 0;
6840 int *arg1 = (int *) 0 ;
6841 int *arg2 = (int *) 0 ;
6842 int temp1 ;
6843 int res1 = SWIG_TMPOBJ ;
6844 int temp2 ;
6845 int res2 = SWIG_TMPOBJ ;
6846
6847 arg1 = &temp1;
6848 arg2 = &temp2;
6849 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6850 {
6851 if (!wxPyCheckForApp()) SWIG_fail;
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 wxDisplaySizeMM(arg1,arg2);
6854 wxPyEndAllowThreads(__tstate);
6855 if (PyErr_Occurred()) SWIG_fail;
6856 }
6857 resultobj = SWIG_Py_Void();
6858 if (SWIG_IsTmpObj(res1)) {
6859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6860 } else {
6861 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6863 }
6864 if (SWIG_IsTmpObj(res2)) {
6865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6866 } else {
6867 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6869 }
6870 return resultobj;
6871 fail:
6872 return NULL;
6873 }
6874
6875
6876 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6877 PyObject *resultobj = 0;
6878 wxSize result;
6879
6880 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6881 {
6882 if (!wxPyCheckForApp()) SWIG_fail;
6883 PyThreadState* __tstate = wxPyBeginAllowThreads();
6884 result = wxGetDisplaySizeMM();
6885 wxPyEndAllowThreads(__tstate);
6886 if (PyErr_Occurred()) SWIG_fail;
6887 }
6888 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6889 return resultobj;
6890 fail:
6891 return NULL;
6892 }
6893
6894
6895 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6896 PyObject *resultobj = 0;
6897 int *arg1 = (int *) 0 ;
6898 int *arg2 = (int *) 0 ;
6899 int *arg3 = (int *) 0 ;
6900 int *arg4 = (int *) 0 ;
6901 int temp1 ;
6902 int res1 = SWIG_TMPOBJ ;
6903 int temp2 ;
6904 int res2 = SWIG_TMPOBJ ;
6905 int temp3 ;
6906 int res3 = SWIG_TMPOBJ ;
6907 int temp4 ;
6908 int res4 = SWIG_TMPOBJ ;
6909
6910 arg1 = &temp1;
6911 arg2 = &temp2;
6912 arg3 = &temp3;
6913 arg4 = &temp4;
6914 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6915 {
6916 if (!wxPyCheckForApp()) SWIG_fail;
6917 PyThreadState* __tstate = wxPyBeginAllowThreads();
6918 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_Py_Void();
6923 if (SWIG_IsTmpObj(res1)) {
6924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6925 } else {
6926 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6928 }
6929 if (SWIG_IsTmpObj(res2)) {
6930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6931 } else {
6932 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6933 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6934 }
6935 if (SWIG_IsTmpObj(res3)) {
6936 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6937 } else {
6938 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6940 }
6941 if (SWIG_IsTmpObj(res4)) {
6942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6943 } else {
6944 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6946 }
6947 return resultobj;
6948 fail:
6949 return NULL;
6950 }
6951
6952
6953 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6954 PyObject *resultobj = 0;
6955 wxRect result;
6956
6957 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6958 {
6959 if (!wxPyCheckForApp()) SWIG_fail;
6960 PyThreadState* __tstate = wxPyBeginAllowThreads();
6961 result = wxGetClientDisplayRect();
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6966 return resultobj;
6967 fail:
6968 return NULL;
6969 }
6970
6971
6972 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6973 PyObject *resultobj = 0;
6974 wxCursor *arg1 = 0 ;
6975 void *argp1 = 0 ;
6976 int res1 = 0 ;
6977 PyObject * obj0 = 0 ;
6978 char * kwnames[] = {
6979 (char *) "cursor", NULL
6980 };
6981
6982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6983 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6984 if (!SWIG_IsOK(res1)) {
6985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6986 }
6987 if (!argp1) {
6988 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6989 }
6990 arg1 = reinterpret_cast< wxCursor * >(argp1);
6991 {
6992 if (!wxPyCheckForApp()) SWIG_fail;
6993 PyThreadState* __tstate = wxPyBeginAllowThreads();
6994 wxSetCursor(*arg1);
6995 wxPyEndAllowThreads(__tstate);
6996 if (PyErr_Occurred()) SWIG_fail;
6997 }
6998 resultobj = SWIG_Py_Void();
6999 return resultobj;
7000 fail:
7001 return NULL;
7002 }
7003
7004
7005 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7006 PyObject *resultobj = 0;
7007 void *result = 0 ;
7008
7009 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7010 {
7011 if (!wxPyCheckForApp()) SWIG_fail;
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 result = (void *)wxGetXDisplay();
7014 wxPyEndAllowThreads(__tstate);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7025 PyObject *resultobj = 0;
7026 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7027 void *argp1 = 0 ;
7028 int res1 = 0 ;
7029 PyObject * obj0 = 0 ;
7030 char * kwnames[] = {
7031 (char *) "cursor", NULL
7032 };
7033
7034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7035 if (obj0) {
7036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7037 if (!SWIG_IsOK(res1)) {
7038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7039 }
7040 arg1 = reinterpret_cast< wxCursor * >(argp1);
7041 }
7042 {
7043 if (!wxPyCheckForApp()) SWIG_fail;
7044 PyThreadState* __tstate = wxPyBeginAllowThreads();
7045 wxBeginBusyCursor(arg1);
7046 wxPyEndAllowThreads(__tstate);
7047 if (PyErr_Occurred()) SWIG_fail;
7048 }
7049 resultobj = SWIG_Py_Void();
7050 return resultobj;
7051 fail:
7052 return NULL;
7053 }
7054
7055
7056 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7057 PyObject *resultobj = 0;
7058 wxPoint result;
7059
7060 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7061 {
7062 if (!wxPyCheckForApp()) SWIG_fail;
7063 PyThreadState* __tstate = wxPyBeginAllowThreads();
7064 result = wxGetMousePosition();
7065 wxPyEndAllowThreads(__tstate);
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7069 return resultobj;
7070 fail:
7071 return NULL;
7072 }
7073
7074
7075 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7076 PyObject *resultobj = 0;
7077 wxWindow *result = 0 ;
7078
7079 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7080 {
7081 if (!wxPyCheckForApp()) SWIG_fail;
7082 PyThreadState* __tstate = wxPyBeginAllowThreads();
7083 result = (wxWindow *)FindWindowAtPointer();
7084 wxPyEndAllowThreads(__tstate);
7085 if (PyErr_Occurred()) SWIG_fail;
7086 }
7087 {
7088 resultobj = wxPyMake_wxObject(result, 0);
7089 }
7090 return resultobj;
7091 fail:
7092 return NULL;
7093 }
7094
7095
7096 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7097 PyObject *resultobj = 0;
7098 wxWindow *result = 0 ;
7099
7100 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7101 {
7102 if (!wxPyCheckForApp()) SWIG_fail;
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = (wxWindow *)wxGetActiveWindow();
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 {
7109 resultobj = wxPyMake_wxObject(result, 0);
7110 }
7111 return resultobj;
7112 fail:
7113 return NULL;
7114 }
7115
7116
7117 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7118 PyObject *resultobj = 0;
7119 wxPoint *arg1 = 0 ;
7120 wxWindow *result = 0 ;
7121 wxPoint temp1 ;
7122 PyObject * obj0 = 0 ;
7123 char * kwnames[] = {
7124 (char *) "pt", NULL
7125 };
7126
7127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7128 {
7129 arg1 = &temp1;
7130 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7131 }
7132 {
7133 if (!wxPyCheckForApp()) SWIG_fail;
7134 PyThreadState* __tstate = wxPyBeginAllowThreads();
7135 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7136 wxPyEndAllowThreads(__tstate);
7137 if (PyErr_Occurred()) SWIG_fail;
7138 }
7139 {
7140 resultobj = wxPyMake_wxObject(result, 0);
7141 }
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj = 0;
7150 wxPoint *arg1 = 0 ;
7151 wxWindow *result = 0 ;
7152 wxPoint temp1 ;
7153 PyObject * obj0 = 0 ;
7154 char * kwnames[] = {
7155 (char *) "pt", NULL
7156 };
7157
7158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7159 {
7160 arg1 = &temp1;
7161 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7162 }
7163 {
7164 if (!wxPyCheckForApp()) SWIG_fail;
7165 PyThreadState* __tstate = wxPyBeginAllowThreads();
7166 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7167 wxPyEndAllowThreads(__tstate);
7168 if (PyErr_Occurred()) SWIG_fail;
7169 }
7170 {
7171 resultobj = wxPyMake_wxObject(result, 0);
7172 }
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7180 PyObject *resultobj = 0;
7181 wxWindow *arg1 = (wxWindow *) 0 ;
7182 wxWindow *result = 0 ;
7183 void *argp1 = 0 ;
7184 int res1 = 0 ;
7185 PyObject * obj0 = 0 ;
7186 char * kwnames[] = {
7187 (char *) "win", NULL
7188 };
7189
7190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7192 if (!SWIG_IsOK(res1)) {
7193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7194 }
7195 arg1 = reinterpret_cast< wxWindow * >(argp1);
7196 {
7197 if (!wxPyCheckForApp()) SWIG_fail;
7198 PyThreadState* __tstate = wxPyBeginAllowThreads();
7199 result = (wxWindow *)wxGetTopLevelParent(arg1);
7200 wxPyEndAllowThreads(__tstate);
7201 if (PyErr_Occurred()) SWIG_fail;
7202 }
7203 {
7204 resultobj = wxPyMake_wxObject(result, 0);
7205 }
7206 return resultobj;
7207 fail:
7208 return NULL;
7209 }
7210
7211
7212 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7213 PyObject *resultobj = 0;
7214 wxString *arg1 = 0 ;
7215 bool result;
7216 bool temp1 = false ;
7217 PyObject * obj0 = 0 ;
7218 char * kwnames[] = {
7219 (char *) "url", NULL
7220 };
7221
7222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7223 {
7224 arg1 = wxString_in_helper(obj0);
7225 if (arg1 == NULL) SWIG_fail;
7226 temp1 = true;
7227 }
7228 {
7229 PyThreadState* __tstate = wxPyBeginAllowThreads();
7230 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7231 wxPyEndAllowThreads(__tstate);
7232 if (PyErr_Occurred()) SWIG_fail;
7233 }
7234 {
7235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7236 }
7237 {
7238 if (temp1)
7239 delete arg1;
7240 }
7241 return resultobj;
7242 fail:
7243 {
7244 if (temp1)
7245 delete arg1;
7246 }
7247 return NULL;
7248 }
7249
7250
7251 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7252 PyObject *resultobj = 0;
7253 wxKeyCode arg1 ;
7254 bool result;
7255 int val1 ;
7256 int ecode1 = 0 ;
7257 PyObject * obj0 = 0 ;
7258 char * kwnames[] = {
7259 (char *) "key", NULL
7260 };
7261
7262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7263 ecode1 = SWIG_AsVal_int(obj0, &val1);
7264 if (!SWIG_IsOK(ecode1)) {
7265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7266 }
7267 arg1 = static_cast< wxKeyCode >(val1);
7268 {
7269 if (!wxPyCheckForApp()) SWIG_fail;
7270 PyThreadState* __tstate = wxPyBeginAllowThreads();
7271 result = (bool)wxGetKeyState(arg1);
7272 wxPyEndAllowThreads(__tstate);
7273 if (PyErr_Occurred()) SWIG_fail;
7274 }
7275 {
7276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7277 }
7278 return resultobj;
7279 fail:
7280 return NULL;
7281 }
7282
7283
7284 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7285 PyObject *resultobj = 0;
7286 wxMouseState *result = 0 ;
7287
7288 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7289 {
7290 PyThreadState* __tstate = wxPyBeginAllowThreads();
7291 result = (wxMouseState *)new wxMouseState();
7292 wxPyEndAllowThreads(__tstate);
7293 if (PyErr_Occurred()) SWIG_fail;
7294 }
7295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7296 return resultobj;
7297 fail:
7298 return NULL;
7299 }
7300
7301
7302 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7303 PyObject *resultobj = 0;
7304 wxMouseState *arg1 = (wxMouseState *) 0 ;
7305 void *argp1 = 0 ;
7306 int res1 = 0 ;
7307 PyObject *swig_obj[1] ;
7308
7309 if (!args) SWIG_fail;
7310 swig_obj[0] = args;
7311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7312 if (!SWIG_IsOK(res1)) {
7313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7314 }
7315 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7316 {
7317 PyThreadState* __tstate = wxPyBeginAllowThreads();
7318 delete arg1;
7319
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 resultobj = SWIG_Py_Void();
7324 return resultobj;
7325 fail:
7326 return NULL;
7327 }
7328
7329
7330 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7331 PyObject *resultobj = 0;
7332 wxMouseState *arg1 = (wxMouseState *) 0 ;
7333 int result;
7334 void *argp1 = 0 ;
7335 int res1 = 0 ;
7336 PyObject *swig_obj[1] ;
7337
7338 if (!args) SWIG_fail;
7339 swig_obj[0] = args;
7340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7341 if (!SWIG_IsOK(res1)) {
7342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7343 }
7344 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7345 {
7346 PyThreadState* __tstate = wxPyBeginAllowThreads();
7347 result = (int)(arg1)->GetX();
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 resultobj = SWIG_From_int(static_cast< int >(result));
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7359 PyObject *resultobj = 0;
7360 wxMouseState *arg1 = (wxMouseState *) 0 ;
7361 int result;
7362 void *argp1 = 0 ;
7363 int res1 = 0 ;
7364 PyObject *swig_obj[1] ;
7365
7366 if (!args) SWIG_fail;
7367 swig_obj[0] = args;
7368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7369 if (!SWIG_IsOK(res1)) {
7370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7371 }
7372 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 result = (int)(arg1)->GetY();
7376 wxPyEndAllowThreads(__tstate);
7377 if (PyErr_Occurred()) SWIG_fail;
7378 }
7379 resultobj = SWIG_From_int(static_cast< int >(result));
7380 return resultobj;
7381 fail:
7382 return NULL;
7383 }
7384
7385
7386 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7387 PyObject *resultobj = 0;
7388 wxMouseState *arg1 = (wxMouseState *) 0 ;
7389 bool result;
7390 void *argp1 = 0 ;
7391 int res1 = 0 ;
7392 PyObject *swig_obj[1] ;
7393
7394 if (!args) SWIG_fail;
7395 swig_obj[0] = args;
7396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7397 if (!SWIG_IsOK(res1)) {
7398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7399 }
7400 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7401 {
7402 PyThreadState* __tstate = wxPyBeginAllowThreads();
7403 result = (bool)(arg1)->LeftDown();
7404 wxPyEndAllowThreads(__tstate);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 {
7408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7409 }
7410 return resultobj;
7411 fail:
7412 return NULL;
7413 }
7414
7415
7416 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7417 PyObject *resultobj = 0;
7418 wxMouseState *arg1 = (wxMouseState *) 0 ;
7419 bool result;
7420 void *argp1 = 0 ;
7421 int res1 = 0 ;
7422 PyObject *swig_obj[1] ;
7423
7424 if (!args) SWIG_fail;
7425 swig_obj[0] = args;
7426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7427 if (!SWIG_IsOK(res1)) {
7428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7429 }
7430 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7431 {
7432 PyThreadState* __tstate = wxPyBeginAllowThreads();
7433 result = (bool)(arg1)->MiddleDown();
7434 wxPyEndAllowThreads(__tstate);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 {
7438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7439 }
7440 return resultobj;
7441 fail:
7442 return NULL;
7443 }
7444
7445
7446 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7447 PyObject *resultobj = 0;
7448 wxMouseState *arg1 = (wxMouseState *) 0 ;
7449 bool result;
7450 void *argp1 = 0 ;
7451 int res1 = 0 ;
7452 PyObject *swig_obj[1] ;
7453
7454 if (!args) SWIG_fail;
7455 swig_obj[0] = args;
7456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7457 if (!SWIG_IsOK(res1)) {
7458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7459 }
7460 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 result = (bool)(arg1)->RightDown();
7464 wxPyEndAllowThreads(__tstate);
7465 if (PyErr_Occurred()) SWIG_fail;
7466 }
7467 {
7468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7469 }
7470 return resultobj;
7471 fail:
7472 return NULL;
7473 }
7474
7475
7476 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7477 PyObject *resultobj = 0;
7478 wxMouseState *arg1 = (wxMouseState *) 0 ;
7479 bool result;
7480 void *argp1 = 0 ;
7481 int res1 = 0 ;
7482 PyObject *swig_obj[1] ;
7483
7484 if (!args) SWIG_fail;
7485 swig_obj[0] = args;
7486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7487 if (!SWIG_IsOK(res1)) {
7488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7489 }
7490 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7491 {
7492 PyThreadState* __tstate = wxPyBeginAllowThreads();
7493 result = (bool)(arg1)->ControlDown();
7494 wxPyEndAllowThreads(__tstate);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 {
7498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7499 }
7500 return resultobj;
7501 fail:
7502 return NULL;
7503 }
7504
7505
7506 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7507 PyObject *resultobj = 0;
7508 wxMouseState *arg1 = (wxMouseState *) 0 ;
7509 bool result;
7510 void *argp1 = 0 ;
7511 int res1 = 0 ;
7512 PyObject *swig_obj[1] ;
7513
7514 if (!args) SWIG_fail;
7515 swig_obj[0] = args;
7516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7517 if (!SWIG_IsOK(res1)) {
7518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7519 }
7520 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7521 {
7522 PyThreadState* __tstate = wxPyBeginAllowThreads();
7523 result = (bool)(arg1)->ShiftDown();
7524 wxPyEndAllowThreads(__tstate);
7525 if (PyErr_Occurred()) SWIG_fail;
7526 }
7527 {
7528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7529 }
7530 return resultobj;
7531 fail:
7532 return NULL;
7533 }
7534
7535
7536 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7537 PyObject *resultobj = 0;
7538 wxMouseState *arg1 = (wxMouseState *) 0 ;
7539 bool result;
7540 void *argp1 = 0 ;
7541 int res1 = 0 ;
7542 PyObject *swig_obj[1] ;
7543
7544 if (!args) SWIG_fail;
7545 swig_obj[0] = args;
7546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7547 if (!SWIG_IsOK(res1)) {
7548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7549 }
7550 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7551 {
7552 PyThreadState* __tstate = wxPyBeginAllowThreads();
7553 result = (bool)(arg1)->AltDown();
7554 wxPyEndAllowThreads(__tstate);
7555 if (PyErr_Occurred()) SWIG_fail;
7556 }
7557 {
7558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7559 }
7560 return resultobj;
7561 fail:
7562 return NULL;
7563 }
7564
7565
7566 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7567 PyObject *resultobj = 0;
7568 wxMouseState *arg1 = (wxMouseState *) 0 ;
7569 bool result;
7570 void *argp1 = 0 ;
7571 int res1 = 0 ;
7572 PyObject *swig_obj[1] ;
7573
7574 if (!args) SWIG_fail;
7575 swig_obj[0] = args;
7576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7577 if (!SWIG_IsOK(res1)) {
7578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7579 }
7580 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7581 {
7582 PyThreadState* __tstate = wxPyBeginAllowThreads();
7583 result = (bool)(arg1)->MetaDown();
7584 wxPyEndAllowThreads(__tstate);
7585 if (PyErr_Occurred()) SWIG_fail;
7586 }
7587 {
7588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7589 }
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7597 PyObject *resultobj = 0;
7598 wxMouseState *arg1 = (wxMouseState *) 0 ;
7599 bool result;
7600 void *argp1 = 0 ;
7601 int res1 = 0 ;
7602 PyObject *swig_obj[1] ;
7603
7604 if (!args) SWIG_fail;
7605 swig_obj[0] = args;
7606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7609 }
7610 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7611 {
7612 PyThreadState* __tstate = wxPyBeginAllowThreads();
7613 result = (bool)(arg1)->CmdDown();
7614 wxPyEndAllowThreads(__tstate);
7615 if (PyErr_Occurred()) SWIG_fail;
7616 }
7617 {
7618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7619 }
7620 return resultobj;
7621 fail:
7622 return NULL;
7623 }
7624
7625
7626 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7627 PyObject *resultobj = 0;
7628 wxMouseState *arg1 = (wxMouseState *) 0 ;
7629 int arg2 ;
7630 void *argp1 = 0 ;
7631 int res1 = 0 ;
7632 int val2 ;
7633 int ecode2 = 0 ;
7634 PyObject * obj0 = 0 ;
7635 PyObject * obj1 = 0 ;
7636 char * kwnames[] = {
7637 (char *) "self",(char *) "x", NULL
7638 };
7639
7640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7642 if (!SWIG_IsOK(res1)) {
7643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7644 }
7645 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7646 ecode2 = SWIG_AsVal_int(obj1, &val2);
7647 if (!SWIG_IsOK(ecode2)) {
7648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7649 }
7650 arg2 = static_cast< int >(val2);
7651 {
7652 PyThreadState* __tstate = wxPyBeginAllowThreads();
7653 (arg1)->SetX(arg2);
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 resultobj = SWIG_Py_Void();
7658 return resultobj;
7659 fail:
7660 return NULL;
7661 }
7662
7663
7664 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7665 PyObject *resultobj = 0;
7666 wxMouseState *arg1 = (wxMouseState *) 0 ;
7667 int arg2 ;
7668 void *argp1 = 0 ;
7669 int res1 = 0 ;
7670 int val2 ;
7671 int ecode2 = 0 ;
7672 PyObject * obj0 = 0 ;
7673 PyObject * obj1 = 0 ;
7674 char * kwnames[] = {
7675 (char *) "self",(char *) "y", NULL
7676 };
7677
7678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7680 if (!SWIG_IsOK(res1)) {
7681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7682 }
7683 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7684 ecode2 = SWIG_AsVal_int(obj1, &val2);
7685 if (!SWIG_IsOK(ecode2)) {
7686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7687 }
7688 arg2 = static_cast< int >(val2);
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 (arg1)->SetY(arg2);
7692 wxPyEndAllowThreads(__tstate);
7693 if (PyErr_Occurred()) SWIG_fail;
7694 }
7695 resultobj = SWIG_Py_Void();
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7703 PyObject *resultobj = 0;
7704 wxMouseState *arg1 = (wxMouseState *) 0 ;
7705 bool arg2 ;
7706 void *argp1 = 0 ;
7707 int res1 = 0 ;
7708 bool val2 ;
7709 int ecode2 = 0 ;
7710 PyObject * obj0 = 0 ;
7711 PyObject * obj1 = 0 ;
7712 char * kwnames[] = {
7713 (char *) "self",(char *) "down", NULL
7714 };
7715
7716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7718 if (!SWIG_IsOK(res1)) {
7719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7720 }
7721 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7722 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7723 if (!SWIG_IsOK(ecode2)) {
7724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7725 }
7726 arg2 = static_cast< bool >(val2);
7727 {
7728 PyThreadState* __tstate = wxPyBeginAllowThreads();
7729 (arg1)->SetLeftDown(arg2);
7730 wxPyEndAllowThreads(__tstate);
7731 if (PyErr_Occurred()) SWIG_fail;
7732 }
7733 resultobj = SWIG_Py_Void();
7734 return resultobj;
7735 fail:
7736 return NULL;
7737 }
7738
7739
7740 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7741 PyObject *resultobj = 0;
7742 wxMouseState *arg1 = (wxMouseState *) 0 ;
7743 bool arg2 ;
7744 void *argp1 = 0 ;
7745 int res1 = 0 ;
7746 bool val2 ;
7747 int ecode2 = 0 ;
7748 PyObject * obj0 = 0 ;
7749 PyObject * obj1 = 0 ;
7750 char * kwnames[] = {
7751 (char *) "self",(char *) "down", NULL
7752 };
7753
7754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7756 if (!SWIG_IsOK(res1)) {
7757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7758 }
7759 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7760 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7761 if (!SWIG_IsOK(ecode2)) {
7762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7763 }
7764 arg2 = static_cast< bool >(val2);
7765 {
7766 PyThreadState* __tstate = wxPyBeginAllowThreads();
7767 (arg1)->SetMiddleDown(arg2);
7768 wxPyEndAllowThreads(__tstate);
7769 if (PyErr_Occurred()) SWIG_fail;
7770 }
7771 resultobj = SWIG_Py_Void();
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj = 0;
7780 wxMouseState *arg1 = (wxMouseState *) 0 ;
7781 bool arg2 ;
7782 void *argp1 = 0 ;
7783 int res1 = 0 ;
7784 bool val2 ;
7785 int ecode2 = 0 ;
7786 PyObject * obj0 = 0 ;
7787 PyObject * obj1 = 0 ;
7788 char * kwnames[] = {
7789 (char *) "self",(char *) "down", NULL
7790 };
7791
7792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7794 if (!SWIG_IsOK(res1)) {
7795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7796 }
7797 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7798 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7799 if (!SWIG_IsOK(ecode2)) {
7800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7801 }
7802 arg2 = static_cast< bool >(val2);
7803 {
7804 PyThreadState* __tstate = wxPyBeginAllowThreads();
7805 (arg1)->SetRightDown(arg2);
7806 wxPyEndAllowThreads(__tstate);
7807 if (PyErr_Occurred()) SWIG_fail;
7808 }
7809 resultobj = SWIG_Py_Void();
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj = 0;
7818 wxMouseState *arg1 = (wxMouseState *) 0 ;
7819 bool arg2 ;
7820 void *argp1 = 0 ;
7821 int res1 = 0 ;
7822 bool val2 ;
7823 int ecode2 = 0 ;
7824 PyObject * obj0 = 0 ;
7825 PyObject * obj1 = 0 ;
7826 char * kwnames[] = {
7827 (char *) "self",(char *) "down", NULL
7828 };
7829
7830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7832 if (!SWIG_IsOK(res1)) {
7833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7834 }
7835 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7836 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7837 if (!SWIG_IsOK(ecode2)) {
7838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7839 }
7840 arg2 = static_cast< bool >(val2);
7841 {
7842 PyThreadState* __tstate = wxPyBeginAllowThreads();
7843 (arg1)->SetControlDown(arg2);
7844 wxPyEndAllowThreads(__tstate);
7845 if (PyErr_Occurred()) SWIG_fail;
7846 }
7847 resultobj = SWIG_Py_Void();
7848 return resultobj;
7849 fail:
7850 return NULL;
7851 }
7852
7853
7854 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7855 PyObject *resultobj = 0;
7856 wxMouseState *arg1 = (wxMouseState *) 0 ;
7857 bool arg2 ;
7858 void *argp1 = 0 ;
7859 int res1 = 0 ;
7860 bool val2 ;
7861 int ecode2 = 0 ;
7862 PyObject * obj0 = 0 ;
7863 PyObject * obj1 = 0 ;
7864 char * kwnames[] = {
7865 (char *) "self",(char *) "down", NULL
7866 };
7867
7868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7870 if (!SWIG_IsOK(res1)) {
7871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7872 }
7873 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7874 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7875 if (!SWIG_IsOK(ecode2)) {
7876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7877 }
7878 arg2 = static_cast< bool >(val2);
7879 {
7880 PyThreadState* __tstate = wxPyBeginAllowThreads();
7881 (arg1)->SetShiftDown(arg2);
7882 wxPyEndAllowThreads(__tstate);
7883 if (PyErr_Occurred()) SWIG_fail;
7884 }
7885 resultobj = SWIG_Py_Void();
7886 return resultobj;
7887 fail:
7888 return NULL;
7889 }
7890
7891
7892 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7893 PyObject *resultobj = 0;
7894 wxMouseState *arg1 = (wxMouseState *) 0 ;
7895 bool arg2 ;
7896 void *argp1 = 0 ;
7897 int res1 = 0 ;
7898 bool val2 ;
7899 int ecode2 = 0 ;
7900 PyObject * obj0 = 0 ;
7901 PyObject * obj1 = 0 ;
7902 char * kwnames[] = {
7903 (char *) "self",(char *) "down", NULL
7904 };
7905
7906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7908 if (!SWIG_IsOK(res1)) {
7909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7910 }
7911 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7912 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7913 if (!SWIG_IsOK(ecode2)) {
7914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7915 }
7916 arg2 = static_cast< bool >(val2);
7917 {
7918 PyThreadState* __tstate = wxPyBeginAllowThreads();
7919 (arg1)->SetAltDown(arg2);
7920 wxPyEndAllowThreads(__tstate);
7921 if (PyErr_Occurred()) SWIG_fail;
7922 }
7923 resultobj = SWIG_Py_Void();
7924 return resultobj;
7925 fail:
7926 return NULL;
7927 }
7928
7929
7930 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7931 PyObject *resultobj = 0;
7932 wxMouseState *arg1 = (wxMouseState *) 0 ;
7933 bool arg2 ;
7934 void *argp1 = 0 ;
7935 int res1 = 0 ;
7936 bool val2 ;
7937 int ecode2 = 0 ;
7938 PyObject * obj0 = 0 ;
7939 PyObject * obj1 = 0 ;
7940 char * kwnames[] = {
7941 (char *) "self",(char *) "down", NULL
7942 };
7943
7944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7946 if (!SWIG_IsOK(res1)) {
7947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7948 }
7949 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7950 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7951 if (!SWIG_IsOK(ecode2)) {
7952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7953 }
7954 arg2 = static_cast< bool >(val2);
7955 {
7956 PyThreadState* __tstate = wxPyBeginAllowThreads();
7957 (arg1)->SetMetaDown(arg2);
7958 wxPyEndAllowThreads(__tstate);
7959 if (PyErr_Occurred()) SWIG_fail;
7960 }
7961 resultobj = SWIG_Py_Void();
7962 return resultobj;
7963 fail:
7964 return NULL;
7965 }
7966
7967
7968 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7969 PyObject *obj;
7970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7971 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7972 return SWIG_Py_Void();
7973 }
7974
7975 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7976 return SWIG_Python_InitShadowInstance(args);
7977 }
7978
7979 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7980 PyObject *resultobj = 0;
7981 wxMouseState result;
7982
7983 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7984 {
7985 PyThreadState* __tstate = wxPyBeginAllowThreads();
7986 result = wxGetMouseState();
7987 wxPyEndAllowThreads(__tstate);
7988 if (PyErr_Occurred()) SWIG_fail;
7989 }
7990 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7991 return resultobj;
7992 fail:
7993 return NULL;
7994 }
7995
7996
7997 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7998 PyObject *resultobj = 0;
7999
8000 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8001 {
8002 if (!wxPyCheckForApp()) SWIG_fail;
8003 PyThreadState* __tstate = wxPyBeginAllowThreads();
8004 wxWakeUpMainThread();
8005 wxPyEndAllowThreads(__tstate);
8006 if (PyErr_Occurred()) SWIG_fail;
8007 }
8008 resultobj = SWIG_Py_Void();
8009 return resultobj;
8010 fail:
8011 return NULL;
8012 }
8013
8014
8015 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8016 PyObject *resultobj = 0;
8017
8018 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8019 {
8020 if (!wxPyCheckForApp()) SWIG_fail;
8021 PyThreadState* __tstate = wxPyBeginAllowThreads();
8022 wxMutexGuiEnter();
8023 wxPyEndAllowThreads(__tstate);
8024 if (PyErr_Occurred()) SWIG_fail;
8025 }
8026 resultobj = SWIG_Py_Void();
8027 return resultobj;
8028 fail:
8029 return NULL;
8030 }
8031
8032
8033 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8034 PyObject *resultobj = 0;
8035
8036 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8037 {
8038 if (!wxPyCheckForApp()) SWIG_fail;
8039 PyThreadState* __tstate = wxPyBeginAllowThreads();
8040 wxMutexGuiLeave();
8041 wxPyEndAllowThreads(__tstate);
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 resultobj = SWIG_Py_Void();
8045 return resultobj;
8046 fail:
8047 return NULL;
8048 }
8049
8050
8051 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8052 PyObject *resultobj = 0;
8053 wxMutexGuiLocker *result = 0 ;
8054
8055 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8056 {
8057 if (!wxPyCheckForApp()) SWIG_fail;
8058 PyThreadState* __tstate = wxPyBeginAllowThreads();
8059 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8060 wxPyEndAllowThreads(__tstate);
8061 if (PyErr_Occurred()) SWIG_fail;
8062 }
8063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8071 PyObject *resultobj = 0;
8072 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8073 void *argp1 = 0 ;
8074 int res1 = 0 ;
8075 PyObject *swig_obj[1] ;
8076
8077 if (!args) SWIG_fail;
8078 swig_obj[0] = args;
8079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8080 if (!SWIG_IsOK(res1)) {
8081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8082 }
8083 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8084 {
8085 PyThreadState* __tstate = wxPyBeginAllowThreads();
8086 delete arg1;
8087
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 resultobj = SWIG_Py_Void();
8092 return resultobj;
8093 fail:
8094 return NULL;
8095 }
8096
8097
8098 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8099 PyObject *obj;
8100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8101 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8102 return SWIG_Py_Void();
8103 }
8104
8105 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8106 return SWIG_Python_InitShadowInstance(args);
8107 }
8108
8109 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8110 PyObject *resultobj = 0;
8111 bool result;
8112
8113 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8114 {
8115 PyThreadState* __tstate = wxPyBeginAllowThreads();
8116 result = (bool)wxThread_IsMain();
8117 wxPyEndAllowThreads(__tstate);
8118 if (PyErr_Occurred()) SWIG_fail;
8119 }
8120 {
8121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8122 }
8123 return resultobj;
8124 fail:
8125 return NULL;
8126 }
8127
8128
8129 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8130 PyObject *resultobj = 0;
8131 wxString *arg1 = 0 ;
8132 wxToolTip *result = 0 ;
8133 bool temp1 = false ;
8134 PyObject * obj0 = 0 ;
8135 char * kwnames[] = {
8136 (char *) "tip", NULL
8137 };
8138
8139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8140 {
8141 arg1 = wxString_in_helper(obj0);
8142 if (arg1 == NULL) SWIG_fail;
8143 temp1 = true;
8144 }
8145 {
8146 if (!wxPyCheckForApp()) SWIG_fail;
8147 PyThreadState* __tstate = wxPyBeginAllowThreads();
8148 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8149 wxPyEndAllowThreads(__tstate);
8150 if (PyErr_Occurred()) SWIG_fail;
8151 }
8152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8153 {
8154 if (temp1)
8155 delete arg1;
8156 }
8157 return resultobj;
8158 fail:
8159 {
8160 if (temp1)
8161 delete arg1;
8162 }
8163 return NULL;
8164 }
8165
8166
8167 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8168 PyObject *resultobj = 0;
8169 wxToolTip *arg1 = (wxToolTip *) 0 ;
8170 void *argp1 = 0 ;
8171 int res1 = 0 ;
8172 PyObject *swig_obj[1] ;
8173
8174 if (!args) SWIG_fail;
8175 swig_obj[0] = args;
8176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8177 if (!SWIG_IsOK(res1)) {
8178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8179 }
8180 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8181 {
8182 PyThreadState* __tstate = wxPyBeginAllowThreads();
8183 delete arg1;
8184
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 resultobj = SWIG_Py_Void();
8189 return resultobj;
8190 fail:
8191 return NULL;
8192 }
8193
8194
8195 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8196 PyObject *resultobj = 0;
8197 wxToolTip *arg1 = (wxToolTip *) 0 ;
8198 wxString *arg2 = 0 ;
8199 void *argp1 = 0 ;
8200 int res1 = 0 ;
8201 bool temp2 = false ;
8202 PyObject * obj0 = 0 ;
8203 PyObject * obj1 = 0 ;
8204 char * kwnames[] = {
8205 (char *) "self",(char *) "tip", NULL
8206 };
8207
8208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8210 if (!SWIG_IsOK(res1)) {
8211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8212 }
8213 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8214 {
8215 arg2 = wxString_in_helper(obj1);
8216 if (arg2 == NULL) SWIG_fail;
8217 temp2 = true;
8218 }
8219 {
8220 PyThreadState* __tstate = wxPyBeginAllowThreads();
8221 (arg1)->SetTip((wxString const &)*arg2);
8222 wxPyEndAllowThreads(__tstate);
8223 if (PyErr_Occurred()) SWIG_fail;
8224 }
8225 resultobj = SWIG_Py_Void();
8226 {
8227 if (temp2)
8228 delete arg2;
8229 }
8230 return resultobj;
8231 fail:
8232 {
8233 if (temp2)
8234 delete arg2;
8235 }
8236 return NULL;
8237 }
8238
8239
8240 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8241 PyObject *resultobj = 0;
8242 wxToolTip *arg1 = (wxToolTip *) 0 ;
8243 wxString result;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 PyObject *swig_obj[1] ;
8247
8248 if (!args) SWIG_fail;
8249 swig_obj[0] = args;
8250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8251 if (!SWIG_IsOK(res1)) {
8252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8253 }
8254 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 result = (arg1)->GetTip();
8258 wxPyEndAllowThreads(__tstate);
8259 if (PyErr_Occurred()) SWIG_fail;
8260 }
8261 {
8262 #if wxUSE_UNICODE
8263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8264 #else
8265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8266 #endif
8267 }
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8275 PyObject *resultobj = 0;
8276 wxToolTip *arg1 = (wxToolTip *) 0 ;
8277 wxWindow *result = 0 ;
8278 void *argp1 = 0 ;
8279 int res1 = 0 ;
8280 PyObject *swig_obj[1] ;
8281
8282 if (!args) SWIG_fail;
8283 swig_obj[0] = args;
8284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8285 if (!SWIG_IsOK(res1)) {
8286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8287 }
8288 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8289 {
8290 PyThreadState* __tstate = wxPyBeginAllowThreads();
8291 result = (wxWindow *)(arg1)->GetWindow();
8292 wxPyEndAllowThreads(__tstate);
8293 if (PyErr_Occurred()) SWIG_fail;
8294 }
8295 {
8296 resultobj = wxPyMake_wxObject(result, 0);
8297 }
8298 return resultobj;
8299 fail:
8300 return NULL;
8301 }
8302
8303
8304 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8305 PyObject *resultobj = 0;
8306 bool arg1 ;
8307 bool val1 ;
8308 int ecode1 = 0 ;
8309 PyObject * obj0 = 0 ;
8310 char * kwnames[] = {
8311 (char *) "flag", NULL
8312 };
8313
8314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8315 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8316 if (!SWIG_IsOK(ecode1)) {
8317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8318 }
8319 arg1 = static_cast< bool >(val1);
8320 {
8321 PyThreadState* __tstate = wxPyBeginAllowThreads();
8322 wxToolTip::Enable(arg1);
8323 wxPyEndAllowThreads(__tstate);
8324 if (PyErr_Occurred()) SWIG_fail;
8325 }
8326 resultobj = SWIG_Py_Void();
8327 return resultobj;
8328 fail:
8329 return NULL;
8330 }
8331
8332
8333 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8334 PyObject *resultobj = 0;
8335 long arg1 ;
8336 long val1 ;
8337 int ecode1 = 0 ;
8338 PyObject * obj0 = 0 ;
8339 char * kwnames[] = {
8340 (char *) "milliseconds", NULL
8341 };
8342
8343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8344 ecode1 = SWIG_AsVal_long(obj0, &val1);
8345 if (!SWIG_IsOK(ecode1)) {
8346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8347 }
8348 arg1 = static_cast< long >(val1);
8349 {
8350 PyThreadState* __tstate = wxPyBeginAllowThreads();
8351 wxToolTip::SetDelay(arg1);
8352 wxPyEndAllowThreads(__tstate);
8353 if (PyErr_Occurred()) SWIG_fail;
8354 }
8355 resultobj = SWIG_Py_Void();
8356 return resultobj;
8357 fail:
8358 return NULL;
8359 }
8360
8361
8362 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8363 PyObject *obj;
8364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8365 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8366 return SWIG_Py_Void();
8367 }
8368
8369 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8370 return SWIG_Python_InitShadowInstance(args);
8371 }
8372
8373 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8374 PyObject *resultobj = 0;
8375 wxWindow *arg1 = (wxWindow *) 0 ;
8376 wxSize *arg2 = 0 ;
8377 wxCaret *result = 0 ;
8378 void *argp1 = 0 ;
8379 int res1 = 0 ;
8380 wxSize temp2 ;
8381 PyObject * obj0 = 0 ;
8382 PyObject * obj1 = 0 ;
8383 char * kwnames[] = {
8384 (char *) "window",(char *) "size", NULL
8385 };
8386
8387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8389 if (!SWIG_IsOK(res1)) {
8390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8391 }
8392 arg1 = reinterpret_cast< wxWindow * >(argp1);
8393 {
8394 arg2 = &temp2;
8395 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8396 }
8397 {
8398 if (!wxPyCheckForApp()) SWIG_fail;
8399 PyThreadState* __tstate = wxPyBeginAllowThreads();
8400 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8401 wxPyEndAllowThreads(__tstate);
8402 if (PyErr_Occurred()) SWIG_fail;
8403 }
8404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8405 return resultobj;
8406 fail:
8407 return NULL;
8408 }
8409
8410
8411 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8412 PyObject *resultobj = 0;
8413 wxCaret *arg1 = (wxCaret *) 0 ;
8414 void *argp1 = 0 ;
8415 int res1 = 0 ;
8416 PyObject *swig_obj[1] ;
8417
8418 if (!args) SWIG_fail;
8419 swig_obj[0] = args;
8420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8421 if (!SWIG_IsOK(res1)) {
8422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8423 }
8424 arg1 = reinterpret_cast< wxCaret * >(argp1);
8425 {
8426 PyThreadState* __tstate = wxPyBeginAllowThreads();
8427 delete arg1;
8428
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 resultobj = SWIG_Py_Void();
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8440 PyObject *resultobj = 0;
8441 wxCaret *arg1 = (wxCaret *) 0 ;
8442 void *argp1 = 0 ;
8443 int res1 = 0 ;
8444 PyObject *swig_obj[1] ;
8445
8446 if (!args) SWIG_fail;
8447 swig_obj[0] = args;
8448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8449 if (!SWIG_IsOK(res1)) {
8450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8451 }
8452 arg1 = reinterpret_cast< wxCaret * >(argp1);
8453 {
8454 PyThreadState* __tstate = wxPyBeginAllowThreads();
8455 wxCaret_Destroy(arg1);
8456 wxPyEndAllowThreads(__tstate);
8457 if (PyErr_Occurred()) SWIG_fail;
8458 }
8459 resultobj = SWIG_Py_Void();
8460 return resultobj;
8461 fail:
8462 return NULL;
8463 }
8464
8465
8466 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8467 PyObject *resultobj = 0;
8468 wxCaret *arg1 = (wxCaret *) 0 ;
8469 bool result;
8470 void *argp1 = 0 ;
8471 int res1 = 0 ;
8472 PyObject *swig_obj[1] ;
8473
8474 if (!args) SWIG_fail;
8475 swig_obj[0] = args;
8476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8477 if (!SWIG_IsOK(res1)) {
8478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8479 }
8480 arg1 = reinterpret_cast< wxCaret * >(argp1);
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 result = (bool)(arg1)->IsOk();
8484 wxPyEndAllowThreads(__tstate);
8485 if (PyErr_Occurred()) SWIG_fail;
8486 }
8487 {
8488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8489 }
8490 return resultobj;
8491 fail:
8492 return NULL;
8493 }
8494
8495
8496 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8497 PyObject *resultobj = 0;
8498 wxCaret *arg1 = (wxCaret *) 0 ;
8499 bool result;
8500 void *argp1 = 0 ;
8501 int res1 = 0 ;
8502 PyObject *swig_obj[1] ;
8503
8504 if (!args) SWIG_fail;
8505 swig_obj[0] = args;
8506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8507 if (!SWIG_IsOK(res1)) {
8508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8509 }
8510 arg1 = reinterpret_cast< wxCaret * >(argp1);
8511 {
8512 PyThreadState* __tstate = wxPyBeginAllowThreads();
8513 result = (bool)(arg1)->IsVisible();
8514 wxPyEndAllowThreads(__tstate);
8515 if (PyErr_Occurred()) SWIG_fail;
8516 }
8517 {
8518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8519 }
8520 return resultobj;
8521 fail:
8522 return NULL;
8523 }
8524
8525
8526 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8527 PyObject *resultobj = 0;
8528 wxCaret *arg1 = (wxCaret *) 0 ;
8529 wxPoint result;
8530 void *argp1 = 0 ;
8531 int res1 = 0 ;
8532 PyObject *swig_obj[1] ;
8533
8534 if (!args) SWIG_fail;
8535 swig_obj[0] = args;
8536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8537 if (!SWIG_IsOK(res1)) {
8538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8539 }
8540 arg1 = reinterpret_cast< wxCaret * >(argp1);
8541 {
8542 PyThreadState* __tstate = wxPyBeginAllowThreads();
8543 result = (arg1)->GetPosition();
8544 wxPyEndAllowThreads(__tstate);
8545 if (PyErr_Occurred()) SWIG_fail;
8546 }
8547 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8548 return resultobj;
8549 fail:
8550 return NULL;
8551 }
8552
8553
8554 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8555 PyObject *resultobj = 0;
8556 wxCaret *arg1 = (wxCaret *) 0 ;
8557 int *arg2 = (int *) 0 ;
8558 int *arg3 = (int *) 0 ;
8559 void *argp1 = 0 ;
8560 int res1 = 0 ;
8561 int temp2 ;
8562 int res2 = SWIG_TMPOBJ ;
8563 int temp3 ;
8564 int res3 = SWIG_TMPOBJ ;
8565 PyObject *swig_obj[1] ;
8566
8567 arg2 = &temp2;
8568 arg3 = &temp3;
8569 if (!args) SWIG_fail;
8570 swig_obj[0] = args;
8571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8572 if (!SWIG_IsOK(res1)) {
8573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8574 }
8575 arg1 = reinterpret_cast< wxCaret * >(argp1);
8576 {
8577 PyThreadState* __tstate = wxPyBeginAllowThreads();
8578 (arg1)->GetPosition(arg2,arg3);
8579 wxPyEndAllowThreads(__tstate);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 resultobj = SWIG_Py_Void();
8583 if (SWIG_IsTmpObj(res2)) {
8584 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8585 } else {
8586 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8588 }
8589 if (SWIG_IsTmpObj(res3)) {
8590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8591 } else {
8592 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8593 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8594 }
8595 return resultobj;
8596 fail:
8597 return NULL;
8598 }
8599
8600
8601 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8602 PyObject *resultobj = 0;
8603 wxCaret *arg1 = (wxCaret *) 0 ;
8604 wxSize result;
8605 void *argp1 = 0 ;
8606 int res1 = 0 ;
8607 PyObject *swig_obj[1] ;
8608
8609 if (!args) SWIG_fail;
8610 swig_obj[0] = args;
8611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8612 if (!SWIG_IsOK(res1)) {
8613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8614 }
8615 arg1 = reinterpret_cast< wxCaret * >(argp1);
8616 {
8617 PyThreadState* __tstate = wxPyBeginAllowThreads();
8618 result = (arg1)->GetSize();
8619 wxPyEndAllowThreads(__tstate);
8620 if (PyErr_Occurred()) SWIG_fail;
8621 }
8622 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8623 return resultobj;
8624 fail:
8625 return NULL;
8626 }
8627
8628
8629 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8630 PyObject *resultobj = 0;
8631 wxCaret *arg1 = (wxCaret *) 0 ;
8632 int *arg2 = (int *) 0 ;
8633 int *arg3 = (int *) 0 ;
8634 void *argp1 = 0 ;
8635 int res1 = 0 ;
8636 int temp2 ;
8637 int res2 = SWIG_TMPOBJ ;
8638 int temp3 ;
8639 int res3 = SWIG_TMPOBJ ;
8640 PyObject *swig_obj[1] ;
8641
8642 arg2 = &temp2;
8643 arg3 = &temp3;
8644 if (!args) SWIG_fail;
8645 swig_obj[0] = args;
8646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8647 if (!SWIG_IsOK(res1)) {
8648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8649 }
8650 arg1 = reinterpret_cast< wxCaret * >(argp1);
8651 {
8652 PyThreadState* __tstate = wxPyBeginAllowThreads();
8653 (arg1)->GetSize(arg2,arg3);
8654 wxPyEndAllowThreads(__tstate);
8655 if (PyErr_Occurred()) SWIG_fail;
8656 }
8657 resultobj = SWIG_Py_Void();
8658 if (SWIG_IsTmpObj(res2)) {
8659 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8660 } else {
8661 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8662 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8663 }
8664 if (SWIG_IsTmpObj(res3)) {
8665 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8666 } else {
8667 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8668 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8669 }
8670 return resultobj;
8671 fail:
8672 return NULL;
8673 }
8674
8675
8676 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8677 PyObject *resultobj = 0;
8678 wxCaret *arg1 = (wxCaret *) 0 ;
8679 wxWindow *result = 0 ;
8680 void *argp1 = 0 ;
8681 int res1 = 0 ;
8682 PyObject *swig_obj[1] ;
8683
8684 if (!args) SWIG_fail;
8685 swig_obj[0] = args;
8686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8687 if (!SWIG_IsOK(res1)) {
8688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8689 }
8690 arg1 = reinterpret_cast< wxCaret * >(argp1);
8691 {
8692 PyThreadState* __tstate = wxPyBeginAllowThreads();
8693 result = (wxWindow *)(arg1)->GetWindow();
8694 wxPyEndAllowThreads(__tstate);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 {
8698 resultobj = wxPyMake_wxObject(result, 0);
8699 }
8700 return resultobj;
8701 fail:
8702 return NULL;
8703 }
8704
8705
8706 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8707 PyObject *resultobj = 0;
8708 wxCaret *arg1 = (wxCaret *) 0 ;
8709 int arg2 ;
8710 int arg3 ;
8711 void *argp1 = 0 ;
8712 int res1 = 0 ;
8713 int val2 ;
8714 int ecode2 = 0 ;
8715 int val3 ;
8716 int ecode3 = 0 ;
8717 PyObject * obj0 = 0 ;
8718 PyObject * obj1 = 0 ;
8719 PyObject * obj2 = 0 ;
8720 char * kwnames[] = {
8721 (char *) "self",(char *) "x",(char *) "y", NULL
8722 };
8723
8724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8726 if (!SWIG_IsOK(res1)) {
8727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8728 }
8729 arg1 = reinterpret_cast< wxCaret * >(argp1);
8730 ecode2 = SWIG_AsVal_int(obj1, &val2);
8731 if (!SWIG_IsOK(ecode2)) {
8732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8733 }
8734 arg2 = static_cast< int >(val2);
8735 ecode3 = SWIG_AsVal_int(obj2, &val3);
8736 if (!SWIG_IsOK(ecode3)) {
8737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8738 }
8739 arg3 = static_cast< int >(val3);
8740 {
8741 PyThreadState* __tstate = wxPyBeginAllowThreads();
8742 (arg1)->Move(arg2,arg3);
8743 wxPyEndAllowThreads(__tstate);
8744 if (PyErr_Occurred()) SWIG_fail;
8745 }
8746 resultobj = SWIG_Py_Void();
8747 return resultobj;
8748 fail:
8749 return NULL;
8750 }
8751
8752
8753 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8754 PyObject *resultobj = 0;
8755 wxCaret *arg1 = (wxCaret *) 0 ;
8756 wxPoint *arg2 = 0 ;
8757 void *argp1 = 0 ;
8758 int res1 = 0 ;
8759 wxPoint temp2 ;
8760 PyObject * obj0 = 0 ;
8761 PyObject * obj1 = 0 ;
8762 char * kwnames[] = {
8763 (char *) "self",(char *) "pt", NULL
8764 };
8765
8766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8768 if (!SWIG_IsOK(res1)) {
8769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8770 }
8771 arg1 = reinterpret_cast< wxCaret * >(argp1);
8772 {
8773 arg2 = &temp2;
8774 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8775 }
8776 {
8777 PyThreadState* __tstate = wxPyBeginAllowThreads();
8778 (arg1)->Move((wxPoint const &)*arg2);
8779 wxPyEndAllowThreads(__tstate);
8780 if (PyErr_Occurred()) SWIG_fail;
8781 }
8782 resultobj = SWIG_Py_Void();
8783 return resultobj;
8784 fail:
8785 return NULL;
8786 }
8787
8788
8789 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8790 PyObject *resultobj = 0;
8791 wxCaret *arg1 = (wxCaret *) 0 ;
8792 int arg2 ;
8793 int arg3 ;
8794 void *argp1 = 0 ;
8795 int res1 = 0 ;
8796 int val2 ;
8797 int ecode2 = 0 ;
8798 int val3 ;
8799 int ecode3 = 0 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 PyObject * obj2 = 0 ;
8803 char * kwnames[] = {
8804 (char *) "self",(char *) "width",(char *) "height", NULL
8805 };
8806
8807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) 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_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8811 }
8812 arg1 = reinterpret_cast< wxCaret * >(argp1);
8813 ecode2 = SWIG_AsVal_int(obj1, &val2);
8814 if (!SWIG_IsOK(ecode2)) {
8815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8816 }
8817 arg2 = static_cast< int >(val2);
8818 ecode3 = SWIG_AsVal_int(obj2, &val3);
8819 if (!SWIG_IsOK(ecode3)) {
8820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8821 }
8822 arg3 = static_cast< int >(val3);
8823 {
8824 PyThreadState* __tstate = wxPyBeginAllowThreads();
8825 (arg1)->SetSize(arg2,arg3);
8826 wxPyEndAllowThreads(__tstate);
8827 if (PyErr_Occurred()) SWIG_fail;
8828 }
8829 resultobj = SWIG_Py_Void();
8830 return resultobj;
8831 fail:
8832 return NULL;
8833 }
8834
8835
8836 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8837 PyObject *resultobj = 0;
8838 wxCaret *arg1 = (wxCaret *) 0 ;
8839 wxSize *arg2 = 0 ;
8840 void *argp1 = 0 ;
8841 int res1 = 0 ;
8842 wxSize temp2 ;
8843 PyObject * obj0 = 0 ;
8844 PyObject * obj1 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "self",(char *) "size", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8853 }
8854 arg1 = reinterpret_cast< wxCaret * >(argp1);
8855 {
8856 arg2 = &temp2;
8857 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8858 }
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 (arg1)->SetSize((wxSize const &)*arg2);
8862 wxPyEndAllowThreads(__tstate);
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 resultobj = SWIG_Py_Void();
8866 return resultobj;
8867 fail:
8868 return NULL;
8869 }
8870
8871
8872 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8873 PyObject *resultobj = 0;
8874 wxCaret *arg1 = (wxCaret *) 0 ;
8875 int arg2 = (int) true ;
8876 void *argp1 = 0 ;
8877 int res1 = 0 ;
8878 int val2 ;
8879 int ecode2 = 0 ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char * kwnames[] = {
8883 (char *) "self",(char *) "show", NULL
8884 };
8885
8886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8888 if (!SWIG_IsOK(res1)) {
8889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8890 }
8891 arg1 = reinterpret_cast< wxCaret * >(argp1);
8892 if (obj1) {
8893 ecode2 = SWIG_AsVal_int(obj1, &val2);
8894 if (!SWIG_IsOK(ecode2)) {
8895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8896 }
8897 arg2 = static_cast< int >(val2);
8898 }
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 (arg1)->Show(arg2);
8902 wxPyEndAllowThreads(__tstate);
8903 if (PyErr_Occurred()) SWIG_fail;
8904 }
8905 resultobj = SWIG_Py_Void();
8906 return resultobj;
8907 fail:
8908 return NULL;
8909 }
8910
8911
8912 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8913 PyObject *resultobj = 0;
8914 wxCaret *arg1 = (wxCaret *) 0 ;
8915 void *argp1 = 0 ;
8916 int res1 = 0 ;
8917 PyObject *swig_obj[1] ;
8918
8919 if (!args) SWIG_fail;
8920 swig_obj[0] = args;
8921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8922 if (!SWIG_IsOK(res1)) {
8923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8924 }
8925 arg1 = reinterpret_cast< wxCaret * >(argp1);
8926 {
8927 PyThreadState* __tstate = wxPyBeginAllowThreads();
8928 (arg1)->Hide();
8929 wxPyEndAllowThreads(__tstate);
8930 if (PyErr_Occurred()) SWIG_fail;
8931 }
8932 resultobj = SWIG_Py_Void();
8933 return resultobj;
8934 fail:
8935 return NULL;
8936 }
8937
8938
8939 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8940 PyObject *resultobj = 0;
8941 int result;
8942
8943 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 result = (int)wxCaret::GetBlinkTime();
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 resultobj = SWIG_From_int(static_cast< int >(result));
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8958 PyObject *resultobj = 0;
8959 int arg1 ;
8960 int val1 ;
8961 int ecode1 = 0 ;
8962 PyObject * obj0 = 0 ;
8963 char * kwnames[] = {
8964 (char *) "milliseconds", NULL
8965 };
8966
8967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8968 ecode1 = SWIG_AsVal_int(obj0, &val1);
8969 if (!SWIG_IsOK(ecode1)) {
8970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8971 }
8972 arg1 = static_cast< int >(val1);
8973 {
8974 PyThreadState* __tstate = wxPyBeginAllowThreads();
8975 wxCaret::SetBlinkTime(arg1);
8976 wxPyEndAllowThreads(__tstate);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 resultobj = SWIG_Py_Void();
8980 return resultobj;
8981 fail:
8982 return NULL;
8983 }
8984
8985
8986 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8987 PyObject *obj;
8988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8989 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8990 return SWIG_Py_Void();
8991 }
8992
8993 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994 return SWIG_Python_InitShadowInstance(args);
8995 }
8996
8997 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8998 PyObject *resultobj = 0;
8999 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9000 wxBusyCursor *result = 0 ;
9001 void *argp1 = 0 ;
9002 int res1 = 0 ;
9003 PyObject * obj0 = 0 ;
9004 char * kwnames[] = {
9005 (char *) "cursor", NULL
9006 };
9007
9008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9009 if (obj0) {
9010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9011 if (!SWIG_IsOK(res1)) {
9012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9013 }
9014 arg1 = reinterpret_cast< wxCursor * >(argp1);
9015 }
9016 {
9017 if (!wxPyCheckForApp()) SWIG_fail;
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9031 PyObject *resultobj = 0;
9032 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9033 void *argp1 = 0 ;
9034 int res1 = 0 ;
9035 PyObject *swig_obj[1] ;
9036
9037 if (!args) SWIG_fail;
9038 swig_obj[0] = args;
9039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9040 if (!SWIG_IsOK(res1)) {
9041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9042 }
9043 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9044 {
9045 PyThreadState* __tstate = wxPyBeginAllowThreads();
9046 delete arg1;
9047
9048 wxPyEndAllowThreads(__tstate);
9049 if (PyErr_Occurred()) SWIG_fail;
9050 }
9051 resultobj = SWIG_Py_Void();
9052 return resultobj;
9053 fail:
9054 return NULL;
9055 }
9056
9057
9058 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9059 PyObject *obj;
9060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9061 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9062 return SWIG_Py_Void();
9063 }
9064
9065 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9066 return SWIG_Python_InitShadowInstance(args);
9067 }
9068
9069 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9070 PyObject *resultobj = 0;
9071 wxWindow *arg1 = (wxWindow *) NULL ;
9072 wxWindowDisabler *result = 0 ;
9073 void *argp1 = 0 ;
9074 int res1 = 0 ;
9075 PyObject * obj0 = 0 ;
9076 char * kwnames[] = {
9077 (char *) "winToSkip", NULL
9078 };
9079
9080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9081 if (obj0) {
9082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9083 if (!SWIG_IsOK(res1)) {
9084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9085 }
9086 arg1 = reinterpret_cast< wxWindow * >(argp1);
9087 }
9088 {
9089 if (!wxPyCheckForApp()) SWIG_fail;
9090 PyThreadState* __tstate = wxPyBeginAllowThreads();
9091 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 PyObject *resultobj = 0;
9104 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9105 void *argp1 = 0 ;
9106 int res1 = 0 ;
9107 PyObject *swig_obj[1] ;
9108
9109 if (!args) SWIG_fail;
9110 swig_obj[0] = args;
9111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9112 if (!SWIG_IsOK(res1)) {
9113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9114 }
9115 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9116 {
9117 PyThreadState* __tstate = wxPyBeginAllowThreads();
9118 delete arg1;
9119
9120 wxPyEndAllowThreads(__tstate);
9121 if (PyErr_Occurred()) SWIG_fail;
9122 }
9123 resultobj = SWIG_Py_Void();
9124 return resultobj;
9125 fail:
9126 return NULL;
9127 }
9128
9129
9130 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9131 PyObject *obj;
9132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9133 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9134 return SWIG_Py_Void();
9135 }
9136
9137 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9138 return SWIG_Python_InitShadowInstance(args);
9139 }
9140
9141 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9142 PyObject *resultobj = 0;
9143 wxString *arg1 = 0 ;
9144 wxWindow *arg2 = (wxWindow *) NULL ;
9145 wxBusyInfo *result = 0 ;
9146 bool temp1 = false ;
9147 void *argp2 = 0 ;
9148 int res2 = 0 ;
9149 PyObject * obj0 = 0 ;
9150 PyObject * obj1 = 0 ;
9151 char * kwnames[] = {
9152 (char *) "message",(char *) "parent", NULL
9153 };
9154
9155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9156 {
9157 arg1 = wxString_in_helper(obj0);
9158 if (arg1 == NULL) SWIG_fail;
9159 temp1 = true;
9160 }
9161 if (obj1) {
9162 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9163 if (!SWIG_IsOK(res2)) {
9164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9165 }
9166 arg2 = reinterpret_cast< wxWindow * >(argp2);
9167 }
9168 {
9169 if (!wxPyCheckForApp()) SWIG_fail;
9170 PyThreadState* __tstate = wxPyBeginAllowThreads();
9171 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9172 wxPyEndAllowThreads(__tstate);
9173 if (PyErr_Occurred()) SWIG_fail;
9174 }
9175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9176 {
9177 if (temp1)
9178 delete arg1;
9179 }
9180 return resultobj;
9181 fail:
9182 {
9183 if (temp1)
9184 delete arg1;
9185 }
9186 return NULL;
9187 }
9188
9189
9190 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9191 PyObject *resultobj = 0;
9192 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9193 void *argp1 = 0 ;
9194 int res1 = 0 ;
9195 PyObject *swig_obj[1] ;
9196
9197 if (!args) SWIG_fail;
9198 swig_obj[0] = args;
9199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9200 if (!SWIG_IsOK(res1)) {
9201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9202 }
9203 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9204 {
9205 PyThreadState* __tstate = wxPyBeginAllowThreads();
9206 delete arg1;
9207
9208 wxPyEndAllowThreads(__tstate);
9209 if (PyErr_Occurred()) SWIG_fail;
9210 }
9211 resultobj = SWIG_Py_Void();
9212 return resultobj;
9213 fail:
9214 return NULL;
9215 }
9216
9217
9218 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9219 PyObject *obj;
9220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9221 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9222 return SWIG_Py_Void();
9223 }
9224
9225 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9226 return SWIG_Python_InitShadowInstance(args);
9227 }
9228
9229 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9230 PyObject *resultobj = 0;
9231 wxStopWatch *result = 0 ;
9232
9233 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9234 {
9235 PyThreadState* __tstate = wxPyBeginAllowThreads();
9236 result = (wxStopWatch *)new wxStopWatch();
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9241 return resultobj;
9242 fail:
9243 return NULL;
9244 }
9245
9246
9247 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9248 PyObject *resultobj = 0;
9249 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9250 void *argp1 = 0 ;
9251 int res1 = 0 ;
9252 PyObject *swig_obj[1] ;
9253
9254 if (!args) SWIG_fail;
9255 swig_obj[0] = args;
9256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9257 if (!SWIG_IsOK(res1)) {
9258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9259 }
9260 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9261 {
9262 PyThreadState* __tstate = wxPyBeginAllowThreads();
9263 delete arg1;
9264
9265 wxPyEndAllowThreads(__tstate);
9266 if (PyErr_Occurred()) SWIG_fail;
9267 }
9268 resultobj = SWIG_Py_Void();
9269 return resultobj;
9270 fail:
9271 return NULL;
9272 }
9273
9274
9275 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9276 PyObject *resultobj = 0;
9277 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9278 long arg2 = (long) 0 ;
9279 void *argp1 = 0 ;
9280 int res1 = 0 ;
9281 long val2 ;
9282 int ecode2 = 0 ;
9283 PyObject * obj0 = 0 ;
9284 PyObject * obj1 = 0 ;
9285 char * kwnames[] = {
9286 (char *) "self",(char *) "t0", NULL
9287 };
9288
9289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9291 if (!SWIG_IsOK(res1)) {
9292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9293 }
9294 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9295 if (obj1) {
9296 ecode2 = SWIG_AsVal_long(obj1, &val2);
9297 if (!SWIG_IsOK(ecode2)) {
9298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9299 }
9300 arg2 = static_cast< long >(val2);
9301 }
9302 {
9303 PyThreadState* __tstate = wxPyBeginAllowThreads();
9304 (arg1)->Start(arg2);
9305 wxPyEndAllowThreads(__tstate);
9306 if (PyErr_Occurred()) SWIG_fail;
9307 }
9308 resultobj = SWIG_Py_Void();
9309 return resultobj;
9310 fail:
9311 return NULL;
9312 }
9313
9314
9315 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9316 PyObject *resultobj = 0;
9317 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9318 void *argp1 = 0 ;
9319 int res1 = 0 ;
9320 PyObject *swig_obj[1] ;
9321
9322 if (!args) SWIG_fail;
9323 swig_obj[0] = args;
9324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9325 if (!SWIG_IsOK(res1)) {
9326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9327 }
9328 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9329 {
9330 PyThreadState* __tstate = wxPyBeginAllowThreads();
9331 (arg1)->Pause();
9332 wxPyEndAllowThreads(__tstate);
9333 if (PyErr_Occurred()) SWIG_fail;
9334 }
9335 resultobj = SWIG_Py_Void();
9336 return resultobj;
9337 fail:
9338 return NULL;
9339 }
9340
9341
9342 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9343 PyObject *resultobj = 0;
9344 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9345 void *argp1 = 0 ;
9346 int res1 = 0 ;
9347 PyObject *swig_obj[1] ;
9348
9349 if (!args) SWIG_fail;
9350 swig_obj[0] = args;
9351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9352 if (!SWIG_IsOK(res1)) {
9353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9354 }
9355 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9356 {
9357 PyThreadState* __tstate = wxPyBeginAllowThreads();
9358 (arg1)->Resume();
9359 wxPyEndAllowThreads(__tstate);
9360 if (PyErr_Occurred()) SWIG_fail;
9361 }
9362 resultobj = SWIG_Py_Void();
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9370 PyObject *resultobj = 0;
9371 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9372 long result;
9373 void *argp1 = 0 ;
9374 int res1 = 0 ;
9375 PyObject *swig_obj[1] ;
9376
9377 if (!args) SWIG_fail;
9378 swig_obj[0] = args;
9379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9380 if (!SWIG_IsOK(res1)) {
9381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9382 }
9383 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9384 {
9385 PyThreadState* __tstate = wxPyBeginAllowThreads();
9386 result = (long)((wxStopWatch const *)arg1)->Time();
9387 wxPyEndAllowThreads(__tstate);
9388 if (PyErr_Occurred()) SWIG_fail;
9389 }
9390 resultobj = SWIG_From_long(static_cast< long >(result));
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9398 PyObject *obj;
9399 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9400 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9401 return SWIG_Py_Void();
9402 }
9403
9404 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9405 return SWIG_Python_InitShadowInstance(args);
9406 }
9407
9408 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9409 PyObject *resultobj = 0;
9410 int arg1 = (int) 9 ;
9411 int arg2 = (int) wxID_FILE1 ;
9412 wxFileHistory *result = 0 ;
9413 int val1 ;
9414 int ecode1 = 0 ;
9415 int val2 ;
9416 int ecode2 = 0 ;
9417 PyObject * obj0 = 0 ;
9418 PyObject * obj1 = 0 ;
9419 char * kwnames[] = {
9420 (char *) "maxFiles",(char *) "idBase", NULL
9421 };
9422
9423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9424 if (obj0) {
9425 ecode1 = SWIG_AsVal_int(obj0, &val1);
9426 if (!SWIG_IsOK(ecode1)) {
9427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9428 }
9429 arg1 = static_cast< int >(val1);
9430 }
9431 if (obj1) {
9432 ecode2 = SWIG_AsVal_int(obj1, &val2);
9433 if (!SWIG_IsOK(ecode2)) {
9434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9435 }
9436 arg2 = static_cast< int >(val2);
9437 }
9438 {
9439 PyThreadState* __tstate = wxPyBeginAllowThreads();
9440 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9441 wxPyEndAllowThreads(__tstate);
9442 if (PyErr_Occurred()) SWIG_fail;
9443 }
9444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9445 return resultobj;
9446 fail:
9447 return NULL;
9448 }
9449
9450
9451 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9452 PyObject *resultobj = 0;
9453 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9454 void *argp1 = 0 ;
9455 int res1 = 0 ;
9456 PyObject *swig_obj[1] ;
9457
9458 if (!args) SWIG_fail;
9459 swig_obj[0] = args;
9460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9461 if (!SWIG_IsOK(res1)) {
9462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9463 }
9464 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9465 {
9466 PyThreadState* __tstate = wxPyBeginAllowThreads();
9467 delete arg1;
9468
9469 wxPyEndAllowThreads(__tstate);
9470 if (PyErr_Occurred()) SWIG_fail;
9471 }
9472 resultobj = SWIG_Py_Void();
9473 return resultobj;
9474 fail:
9475 return NULL;
9476 }
9477
9478
9479 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9480 PyObject *resultobj = 0;
9481 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9482 wxString *arg2 = 0 ;
9483 void *argp1 = 0 ;
9484 int res1 = 0 ;
9485 bool temp2 = false ;
9486 PyObject * obj0 = 0 ;
9487 PyObject * obj1 = 0 ;
9488 char * kwnames[] = {
9489 (char *) "self",(char *) "file", NULL
9490 };
9491
9492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9494 if (!SWIG_IsOK(res1)) {
9495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9496 }
9497 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9498 {
9499 arg2 = wxString_in_helper(obj1);
9500 if (arg2 == NULL) SWIG_fail;
9501 temp2 = true;
9502 }
9503 {
9504 PyThreadState* __tstate = wxPyBeginAllowThreads();
9505 (arg1)->AddFileToHistory((wxString const &)*arg2);
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_Py_Void();
9510 {
9511 if (temp2)
9512 delete arg2;
9513 }
9514 return resultobj;
9515 fail:
9516 {
9517 if (temp2)
9518 delete arg2;
9519 }
9520 return NULL;
9521 }
9522
9523
9524 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9525 PyObject *resultobj = 0;
9526 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9527 int arg2 ;
9528 void *argp1 = 0 ;
9529 int res1 = 0 ;
9530 int val2 ;
9531 int ecode2 = 0 ;
9532 PyObject * obj0 = 0 ;
9533 PyObject * obj1 = 0 ;
9534 char * kwnames[] = {
9535 (char *) "self",(char *) "i", NULL
9536 };
9537
9538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9540 if (!SWIG_IsOK(res1)) {
9541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9542 }
9543 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9544 ecode2 = SWIG_AsVal_int(obj1, &val2);
9545 if (!SWIG_IsOK(ecode2)) {
9546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9547 }
9548 arg2 = static_cast< int >(val2);
9549 {
9550 PyThreadState* __tstate = wxPyBeginAllowThreads();
9551 (arg1)->RemoveFileFromHistory(arg2);
9552 wxPyEndAllowThreads(__tstate);
9553 if (PyErr_Occurred()) SWIG_fail;
9554 }
9555 resultobj = SWIG_Py_Void();
9556 return resultobj;
9557 fail:
9558 return NULL;
9559 }
9560
9561
9562 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9563 PyObject *resultobj = 0;
9564 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9565 int result;
9566 void *argp1 = 0 ;
9567 int res1 = 0 ;
9568 PyObject *swig_obj[1] ;
9569
9570 if (!args) SWIG_fail;
9571 swig_obj[0] = args;
9572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9573 if (!SWIG_IsOK(res1)) {
9574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9575 }
9576 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9577 {
9578 PyThreadState* __tstate = wxPyBeginAllowThreads();
9579 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9580 wxPyEndAllowThreads(__tstate);
9581 if (PyErr_Occurred()) SWIG_fail;
9582 }
9583 resultobj = SWIG_From_int(static_cast< int >(result));
9584 return resultobj;
9585 fail:
9586 return NULL;
9587 }
9588
9589
9590 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9591 PyObject *resultobj = 0;
9592 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9593 wxMenu *arg2 = (wxMenu *) 0 ;
9594 void *argp1 = 0 ;
9595 int res1 = 0 ;
9596 void *argp2 = 0 ;
9597 int res2 = 0 ;
9598 PyObject * obj0 = 0 ;
9599 PyObject * obj1 = 0 ;
9600 char * kwnames[] = {
9601 (char *) "self",(char *) "menu", NULL
9602 };
9603
9604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9606 if (!SWIG_IsOK(res1)) {
9607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9608 }
9609 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9610 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9611 if (!SWIG_IsOK(res2)) {
9612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9613 }
9614 arg2 = reinterpret_cast< wxMenu * >(argp2);
9615 {
9616 PyThreadState* __tstate = wxPyBeginAllowThreads();
9617 (arg1)->UseMenu(arg2);
9618 wxPyEndAllowThreads(__tstate);
9619 if (PyErr_Occurred()) SWIG_fail;
9620 }
9621 resultobj = SWIG_Py_Void();
9622 return resultobj;
9623 fail:
9624 return NULL;
9625 }
9626
9627
9628 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9629 PyObject *resultobj = 0;
9630 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9631 wxMenu *arg2 = (wxMenu *) 0 ;
9632 void *argp1 = 0 ;
9633 int res1 = 0 ;
9634 void *argp2 = 0 ;
9635 int res2 = 0 ;
9636 PyObject * obj0 = 0 ;
9637 PyObject * obj1 = 0 ;
9638 char * kwnames[] = {
9639 (char *) "self",(char *) "menu", NULL
9640 };
9641
9642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9644 if (!SWIG_IsOK(res1)) {
9645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9646 }
9647 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9648 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9649 if (!SWIG_IsOK(res2)) {
9650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9651 }
9652 arg2 = reinterpret_cast< wxMenu * >(argp2);
9653 {
9654 PyThreadState* __tstate = wxPyBeginAllowThreads();
9655 (arg1)->RemoveMenu(arg2);
9656 wxPyEndAllowThreads(__tstate);
9657 if (PyErr_Occurred()) SWIG_fail;
9658 }
9659 resultobj = SWIG_Py_Void();
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9667 PyObject *resultobj = 0;
9668 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9669 wxConfigBase *arg2 = 0 ;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 void *argp2 = 0 ;
9673 int res2 = 0 ;
9674 PyObject * obj0 = 0 ;
9675 PyObject * obj1 = 0 ;
9676 char * kwnames[] = {
9677 (char *) "self",(char *) "config", NULL
9678 };
9679
9680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9682 if (!SWIG_IsOK(res1)) {
9683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9684 }
9685 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9686 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9687 if (!SWIG_IsOK(res2)) {
9688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9689 }
9690 if (!argp2) {
9691 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9692 }
9693 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9694 {
9695 PyThreadState* __tstate = wxPyBeginAllowThreads();
9696 (arg1)->Load(*arg2);
9697 wxPyEndAllowThreads(__tstate);
9698 if (PyErr_Occurred()) SWIG_fail;
9699 }
9700 resultobj = SWIG_Py_Void();
9701 return resultobj;
9702 fail:
9703 return NULL;
9704 }
9705
9706
9707 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9708 PyObject *resultobj = 0;
9709 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9710 wxConfigBase *arg2 = 0 ;
9711 void *argp1 = 0 ;
9712 int res1 = 0 ;
9713 void *argp2 = 0 ;
9714 int res2 = 0 ;
9715 PyObject * obj0 = 0 ;
9716 PyObject * obj1 = 0 ;
9717 char * kwnames[] = {
9718 (char *) "self",(char *) "config", NULL
9719 };
9720
9721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9723 if (!SWIG_IsOK(res1)) {
9724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9725 }
9726 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9727 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9728 if (!SWIG_IsOK(res2)) {
9729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9730 }
9731 if (!argp2) {
9732 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9733 }
9734 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9735 {
9736 PyThreadState* __tstate = wxPyBeginAllowThreads();
9737 (arg1)->Save(*arg2);
9738 wxPyEndAllowThreads(__tstate);
9739 if (PyErr_Occurred()) SWIG_fail;
9740 }
9741 resultobj = SWIG_Py_Void();
9742 return resultobj;
9743 fail:
9744 return NULL;
9745 }
9746
9747
9748 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9749 PyObject *resultobj = 0;
9750 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9751 void *argp1 = 0 ;
9752 int res1 = 0 ;
9753 PyObject *swig_obj[1] ;
9754
9755 if (!args) SWIG_fail;
9756 swig_obj[0] = args;
9757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9758 if (!SWIG_IsOK(res1)) {
9759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9760 }
9761 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9762 {
9763 PyThreadState* __tstate = wxPyBeginAllowThreads();
9764 (arg1)->AddFilesToMenu();
9765 wxPyEndAllowThreads(__tstate);
9766 if (PyErr_Occurred()) SWIG_fail;
9767 }
9768 resultobj = SWIG_Py_Void();
9769 return resultobj;
9770 fail:
9771 return NULL;
9772 }
9773
9774
9775 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9776 PyObject *resultobj = 0;
9777 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9778 wxMenu *arg2 = (wxMenu *) 0 ;
9779 void *argp1 = 0 ;
9780 int res1 = 0 ;
9781 void *argp2 = 0 ;
9782 int res2 = 0 ;
9783 PyObject * obj0 = 0 ;
9784 PyObject * obj1 = 0 ;
9785 char * kwnames[] = {
9786 (char *) "self",(char *) "menu", NULL
9787 };
9788
9789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9791 if (!SWIG_IsOK(res1)) {
9792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9793 }
9794 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9796 if (!SWIG_IsOK(res2)) {
9797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9798 }
9799 arg2 = reinterpret_cast< wxMenu * >(argp2);
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 (arg1)->AddFilesToMenu(arg2);
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 resultobj = SWIG_Py_Void();
9807 return resultobj;
9808 fail:
9809 return NULL;
9810 }
9811
9812
9813 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9814 PyObject *resultobj = 0;
9815 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9816 int arg2 ;
9817 wxString result;
9818 void *argp1 = 0 ;
9819 int res1 = 0 ;
9820 int val2 ;
9821 int ecode2 = 0 ;
9822 PyObject * obj0 = 0 ;
9823 PyObject * obj1 = 0 ;
9824 char * kwnames[] = {
9825 (char *) "self",(char *) "i", NULL
9826 };
9827
9828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9830 if (!SWIG_IsOK(res1)) {
9831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9832 }
9833 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9834 ecode2 = SWIG_AsVal_int(obj1, &val2);
9835 if (!SWIG_IsOK(ecode2)) {
9836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9837 }
9838 arg2 = static_cast< int >(val2);
9839 {
9840 PyThreadState* __tstate = wxPyBeginAllowThreads();
9841 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9842 wxPyEndAllowThreads(__tstate);
9843 if (PyErr_Occurred()) SWIG_fail;
9844 }
9845 {
9846 #if wxUSE_UNICODE
9847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9848 #else
9849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9850 #endif
9851 }
9852 return resultobj;
9853 fail:
9854 return NULL;
9855 }
9856
9857
9858 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9859 PyObject *resultobj = 0;
9860 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9861 int result;
9862 void *argp1 = 0 ;
9863 int res1 = 0 ;
9864 PyObject *swig_obj[1] ;
9865
9866 if (!args) SWIG_fail;
9867 swig_obj[0] = args;
9868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9869 if (!SWIG_IsOK(res1)) {
9870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9871 }
9872 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9873 {
9874 PyThreadState* __tstate = wxPyBeginAllowThreads();
9875 result = (int)((wxFileHistory const *)arg1)->GetCount();
9876 wxPyEndAllowThreads(__tstate);
9877 if (PyErr_Occurred()) SWIG_fail;
9878 }
9879 resultobj = SWIG_From_int(static_cast< int >(result));
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9887 PyObject *obj;
9888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9889 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9890 return SWIG_Py_Void();
9891 }
9892
9893 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9894 return SWIG_Python_InitShadowInstance(args);
9895 }
9896
9897 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9898 PyObject *resultobj = 0;
9899 wxString *arg1 = 0 ;
9900 wxString const &arg2_defvalue = wxPyEmptyString ;
9901 wxString *arg2 = (wxString *) &arg2_defvalue ;
9902 wxSingleInstanceChecker *result = 0 ;
9903 bool temp1 = false ;
9904 bool temp2 = false ;
9905 PyObject * obj0 = 0 ;
9906 PyObject * obj1 = 0 ;
9907 char * kwnames[] = {
9908 (char *) "name",(char *) "path", NULL
9909 };
9910
9911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9912 {
9913 arg1 = wxString_in_helper(obj0);
9914 if (arg1 == NULL) SWIG_fail;
9915 temp1 = true;
9916 }
9917 if (obj1) {
9918 {
9919 arg2 = wxString_in_helper(obj1);
9920 if (arg2 == NULL) SWIG_fail;
9921 temp2 = true;
9922 }
9923 }
9924 {
9925 PyThreadState* __tstate = wxPyBeginAllowThreads();
9926 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9927 wxPyEndAllowThreads(__tstate);
9928 if (PyErr_Occurred()) SWIG_fail;
9929 }
9930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9931 {
9932 if (temp1)
9933 delete arg1;
9934 }
9935 {
9936 if (temp2)
9937 delete arg2;
9938 }
9939 return resultobj;
9940 fail:
9941 {
9942 if (temp1)
9943 delete arg1;
9944 }
9945 {
9946 if (temp2)
9947 delete arg2;
9948 }
9949 return NULL;
9950 }
9951
9952
9953 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9954 PyObject *resultobj = 0;
9955 wxSingleInstanceChecker *result = 0 ;
9956
9957 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9958 {
9959 PyThreadState* __tstate = wxPyBeginAllowThreads();
9960 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9961 wxPyEndAllowThreads(__tstate);
9962 if (PyErr_Occurred()) SWIG_fail;
9963 }
9964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9965 return resultobj;
9966 fail:
9967 return NULL;
9968 }
9969
9970
9971 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9972 PyObject *resultobj = 0;
9973 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9974 void *argp1 = 0 ;
9975 int res1 = 0 ;
9976 PyObject *swig_obj[1] ;
9977
9978 if (!args) SWIG_fail;
9979 swig_obj[0] = args;
9980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9981 if (!SWIG_IsOK(res1)) {
9982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9983 }
9984 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9985 {
9986 PyThreadState* __tstate = wxPyBeginAllowThreads();
9987 delete arg1;
9988
9989 wxPyEndAllowThreads(__tstate);
9990 if (PyErr_Occurred()) SWIG_fail;
9991 }
9992 resultobj = SWIG_Py_Void();
9993 return resultobj;
9994 fail:
9995 return NULL;
9996 }
9997
9998
9999 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10000 PyObject *resultobj = 0;
10001 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10002 wxString *arg2 = 0 ;
10003 wxString const &arg3_defvalue = wxPyEmptyString ;
10004 wxString *arg3 = (wxString *) &arg3_defvalue ;
10005 bool result;
10006 void *argp1 = 0 ;
10007 int res1 = 0 ;
10008 bool temp2 = false ;
10009 bool temp3 = false ;
10010 PyObject * obj0 = 0 ;
10011 PyObject * obj1 = 0 ;
10012 PyObject * obj2 = 0 ;
10013 char * kwnames[] = {
10014 (char *) "self",(char *) "name",(char *) "path", NULL
10015 };
10016
10017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10019 if (!SWIG_IsOK(res1)) {
10020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10021 }
10022 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10023 {
10024 arg2 = wxString_in_helper(obj1);
10025 if (arg2 == NULL) SWIG_fail;
10026 temp2 = true;
10027 }
10028 if (obj2) {
10029 {
10030 arg3 = wxString_in_helper(obj2);
10031 if (arg3 == NULL) SWIG_fail;
10032 temp3 = true;
10033 }
10034 }
10035 {
10036 PyThreadState* __tstate = wxPyBeginAllowThreads();
10037 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10038 wxPyEndAllowThreads(__tstate);
10039 if (PyErr_Occurred()) SWIG_fail;
10040 }
10041 {
10042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10043 }
10044 {
10045 if (temp2)
10046 delete arg2;
10047 }
10048 {
10049 if (temp3)
10050 delete arg3;
10051 }
10052 return resultobj;
10053 fail:
10054 {
10055 if (temp2)
10056 delete arg2;
10057 }
10058 {
10059 if (temp3)
10060 delete arg3;
10061 }
10062 return NULL;
10063 }
10064
10065
10066 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10067 PyObject *resultobj = 0;
10068 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10069 bool result;
10070 void *argp1 = 0 ;
10071 int res1 = 0 ;
10072 PyObject *swig_obj[1] ;
10073
10074 if (!args) SWIG_fail;
10075 swig_obj[0] = args;
10076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10077 if (!SWIG_IsOK(res1)) {
10078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10079 }
10080 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10084 wxPyEndAllowThreads(__tstate);
10085 if (PyErr_Occurred()) SWIG_fail;
10086 }
10087 {
10088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10089 }
10090 return resultobj;
10091 fail:
10092 return NULL;
10093 }
10094
10095
10096 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10097 PyObject *obj;
10098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10099 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10100 return SWIG_Py_Void();
10101 }
10102
10103 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10104 return SWIG_Python_InitShadowInstance(args);
10105 }
10106
10107 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10108 PyObject *resultobj = 0;
10109 wxPlatformInfo *result = 0 ;
10110
10111 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10112 {
10113 PyThreadState* __tstate = wxPyBeginAllowThreads();
10114 result = (wxPlatformInfo *)new wxPlatformInfo();
10115 wxPyEndAllowThreads(__tstate);
10116 if (PyErr_Occurred()) SWIG_fail;
10117 }
10118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10119 return resultobj;
10120 fail:
10121 return NULL;
10122 }
10123
10124
10125 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10126 PyObject *resultobj = 0;
10127 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10128 wxPlatformInfo *arg2 = 0 ;
10129 bool result;
10130 void *argp1 = 0 ;
10131 int res1 = 0 ;
10132 void *argp2 = 0 ;
10133 int res2 = 0 ;
10134 PyObject * obj0 = 0 ;
10135 PyObject * obj1 = 0 ;
10136 char * kwnames[] = {
10137 (char *) "self",(char *) "t", NULL
10138 };
10139
10140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10142 if (!SWIG_IsOK(res1)) {
10143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10144 }
10145 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10147 if (!SWIG_IsOK(res2)) {
10148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10149 }
10150 if (!argp2) {
10151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10152 }
10153 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10154 {
10155 PyThreadState* __tstate = wxPyBeginAllowThreads();
10156 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10157 wxPyEndAllowThreads(__tstate);
10158 if (PyErr_Occurred()) SWIG_fail;
10159 }
10160 {
10161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10162 }
10163 return resultobj;
10164 fail:
10165 return NULL;
10166 }
10167
10168
10169 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10170 PyObject *resultobj = 0;
10171 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10172 wxPlatformInfo *arg2 = 0 ;
10173 bool result;
10174 void *argp1 = 0 ;
10175 int res1 = 0 ;
10176 void *argp2 = 0 ;
10177 int res2 = 0 ;
10178 PyObject * obj0 = 0 ;
10179 PyObject * obj1 = 0 ;
10180 char * kwnames[] = {
10181 (char *) "self",(char *) "t", NULL
10182 };
10183
10184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10186 if (!SWIG_IsOK(res1)) {
10187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10188 }
10189 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10190 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10191 if (!SWIG_IsOK(res2)) {
10192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10193 }
10194 if (!argp2) {
10195 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10196 }
10197 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10198 {
10199 PyThreadState* __tstate = wxPyBeginAllowThreads();
10200 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10201 wxPyEndAllowThreads(__tstate);
10202 if (PyErr_Occurred()) SWIG_fail;
10203 }
10204 {
10205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10206 }
10207 return resultobj;
10208 fail:
10209 return NULL;
10210 }
10211
10212
10213 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10214 PyObject *resultobj = 0;
10215 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10216 int result;
10217 void *argp1 = 0 ;
10218 int res1 = 0 ;
10219 PyObject *swig_obj[1] ;
10220
10221 if (!args) SWIG_fail;
10222 swig_obj[0] = args;
10223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10224 if (!SWIG_IsOK(res1)) {
10225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10226 }
10227 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10228 {
10229 PyThreadState* __tstate = wxPyBeginAllowThreads();
10230 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10231 wxPyEndAllowThreads(__tstate);
10232 if (PyErr_Occurred()) SWIG_fail;
10233 }
10234 resultobj = SWIG_From_int(static_cast< int >(result));
10235 return resultobj;
10236 fail:
10237 return NULL;
10238 }
10239
10240
10241 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10242 PyObject *resultobj = 0;
10243 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10244 int result;
10245 void *argp1 = 0 ;
10246 int res1 = 0 ;
10247 PyObject *swig_obj[1] ;
10248
10249 if (!args) SWIG_fail;
10250 swig_obj[0] = args;
10251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10252 if (!SWIG_IsOK(res1)) {
10253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10254 }
10255 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10256 {
10257 PyThreadState* __tstate = wxPyBeginAllowThreads();
10258 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10259 wxPyEndAllowThreads(__tstate);
10260 if (PyErr_Occurred()) SWIG_fail;
10261 }
10262 resultobj = SWIG_From_int(static_cast< int >(result));
10263 return resultobj;
10264 fail:
10265 return NULL;
10266 }
10267
10268
10269 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10270 PyObject *resultobj = 0;
10271 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10272 int arg2 ;
10273 int arg3 ;
10274 bool result;
10275 void *argp1 = 0 ;
10276 int res1 = 0 ;
10277 int val2 ;
10278 int ecode2 = 0 ;
10279 int val3 ;
10280 int ecode3 = 0 ;
10281 PyObject * obj0 = 0 ;
10282 PyObject * obj1 = 0 ;
10283 PyObject * obj2 = 0 ;
10284 char * kwnames[] = {
10285 (char *) "self",(char *) "major",(char *) "minor", NULL
10286 };
10287
10288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10290 if (!SWIG_IsOK(res1)) {
10291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10292 }
10293 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10294 ecode2 = SWIG_AsVal_int(obj1, &val2);
10295 if (!SWIG_IsOK(ecode2)) {
10296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10297 }
10298 arg2 = static_cast< int >(val2);
10299 ecode3 = SWIG_AsVal_int(obj2, &val3);
10300 if (!SWIG_IsOK(ecode3)) {
10301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10302 }
10303 arg3 = static_cast< int >(val3);
10304 {
10305 PyThreadState* __tstate = wxPyBeginAllowThreads();
10306 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10307 wxPyEndAllowThreads(__tstate);
10308 if (PyErr_Occurred()) SWIG_fail;
10309 }
10310 {
10311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10312 }
10313 return resultobj;
10314 fail:
10315 return NULL;
10316 }
10317
10318
10319 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10320 PyObject *resultobj = 0;
10321 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10322 int result;
10323 void *argp1 = 0 ;
10324 int res1 = 0 ;
10325 PyObject *swig_obj[1] ;
10326
10327 if (!args) SWIG_fail;
10328 swig_obj[0] = args;
10329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10330 if (!SWIG_IsOK(res1)) {
10331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10332 }
10333 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 resultobj = SWIG_From_int(static_cast< int >(result));
10341 return resultobj;
10342 fail:
10343 return NULL;
10344 }
10345
10346
10347 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10348 PyObject *resultobj = 0;
10349 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10350 int result;
10351 void *argp1 = 0 ;
10352 int res1 = 0 ;
10353 PyObject *swig_obj[1] ;
10354
10355 if (!args) SWIG_fail;
10356 swig_obj[0] = args;
10357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10358 if (!SWIG_IsOK(res1)) {
10359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10360 }
10361 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10362 {
10363 PyThreadState* __tstate = wxPyBeginAllowThreads();
10364 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10365 wxPyEndAllowThreads(__tstate);
10366 if (PyErr_Occurred()) SWIG_fail;
10367 }
10368 resultobj = SWIG_From_int(static_cast< int >(result));
10369 return resultobj;
10370 fail:
10371 return NULL;
10372 }
10373
10374
10375 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10376 PyObject *resultobj = 0;
10377 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10378 int arg2 ;
10379 int arg3 ;
10380 bool result;
10381 void *argp1 = 0 ;
10382 int res1 = 0 ;
10383 int val2 ;
10384 int ecode2 = 0 ;
10385 int val3 ;
10386 int ecode3 = 0 ;
10387 PyObject * obj0 = 0 ;
10388 PyObject * obj1 = 0 ;
10389 PyObject * obj2 = 0 ;
10390 char * kwnames[] = {
10391 (char *) "self",(char *) "major",(char *) "minor", NULL
10392 };
10393
10394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10396 if (!SWIG_IsOK(res1)) {
10397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10398 }
10399 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10400 ecode2 = SWIG_AsVal_int(obj1, &val2);
10401 if (!SWIG_IsOK(ecode2)) {
10402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10403 }
10404 arg2 = static_cast< int >(val2);
10405 ecode3 = SWIG_AsVal_int(obj2, &val3);
10406 if (!SWIG_IsOK(ecode3)) {
10407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10408 }
10409 arg3 = static_cast< int >(val3);
10410 {
10411 PyThreadState* __tstate = wxPyBeginAllowThreads();
10412 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10413 wxPyEndAllowThreads(__tstate);
10414 if (PyErr_Occurred()) SWIG_fail;
10415 }
10416 {
10417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10418 }
10419 return resultobj;
10420 fail:
10421 return NULL;
10422 }
10423
10424
10425 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10426 PyObject *resultobj = 0;
10427 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10428 bool result;
10429 void *argp1 = 0 ;
10430 int res1 = 0 ;
10431 PyObject *swig_obj[1] ;
10432
10433 if (!args) SWIG_fail;
10434 swig_obj[0] = args;
10435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10436 if (!SWIG_IsOK(res1)) {
10437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10438 }
10439 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10440 {
10441 PyThreadState* __tstate = wxPyBeginAllowThreads();
10442 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
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_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10456 PyObject *resultobj = 0;
10457 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10458 wxOperatingSystemId 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_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10468 }
10469 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10470 {
10471 PyThreadState* __tstate = wxPyBeginAllowThreads();
10472 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10473 wxPyEndAllowThreads(__tstate);
10474 if (PyErr_Occurred()) SWIG_fail;
10475 }
10476 resultobj = SWIG_From_int(static_cast< int >(result));
10477 return resultobj;
10478 fail:
10479 return NULL;
10480 }
10481
10482
10483 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10484 PyObject *resultobj = 0;
10485 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10486 wxPortId result;
10487 void *argp1 = 0 ;
10488 int res1 = 0 ;
10489 PyObject *swig_obj[1] ;
10490
10491 if (!args) SWIG_fail;
10492 swig_obj[0] = args;
10493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10494 if (!SWIG_IsOK(res1)) {
10495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10496 }
10497 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10498 {
10499 PyThreadState* __tstate = wxPyBeginAllowThreads();
10500 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10501 wxPyEndAllowThreads(__tstate);
10502 if (PyErr_Occurred()) SWIG_fail;
10503 }
10504 resultobj = SWIG_From_int(static_cast< int >(result));
10505 return resultobj;
10506 fail:
10507 return NULL;
10508 }
10509
10510
10511 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10512 PyObject *resultobj = 0;
10513 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10514 wxArchitecture result;
10515 void *argp1 = 0 ;
10516 int res1 = 0 ;
10517 PyObject *swig_obj[1] ;
10518
10519 if (!args) SWIG_fail;
10520 swig_obj[0] = args;
10521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10522 if (!SWIG_IsOK(res1)) {
10523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10524 }
10525 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10526 {
10527 PyThreadState* __tstate = wxPyBeginAllowThreads();
10528 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10529 wxPyEndAllowThreads(__tstate);
10530 if (PyErr_Occurred()) SWIG_fail;
10531 }
10532 resultobj = SWIG_From_int(static_cast< int >(result));
10533 return resultobj;
10534 fail:
10535 return NULL;
10536 }
10537
10538
10539 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10540 PyObject *resultobj = 0;
10541 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10542 wxEndianness result;
10543 void *argp1 = 0 ;
10544 int res1 = 0 ;
10545 PyObject *swig_obj[1] ;
10546
10547 if (!args) SWIG_fail;
10548 swig_obj[0] = args;
10549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10550 if (!SWIG_IsOK(res1)) {
10551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10552 }
10553 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10554 {
10555 PyThreadState* __tstate = wxPyBeginAllowThreads();
10556 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 resultobj = SWIG_From_int(static_cast< int >(result));
10561 return resultobj;
10562 fail:
10563 return NULL;
10564 }
10565
10566
10567 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10568 PyObject *resultobj = 0;
10569 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10570 wxString result;
10571 void *argp1 = 0 ;
10572 int res1 = 0 ;
10573 PyObject *swig_obj[1] ;
10574
10575 if (!args) SWIG_fail;
10576 swig_obj[0] = args;
10577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10578 if (!SWIG_IsOK(res1)) {
10579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10580 }
10581 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10582 {
10583 PyThreadState* __tstate = wxPyBeginAllowThreads();
10584 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10585 wxPyEndAllowThreads(__tstate);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 {
10589 #if wxUSE_UNICODE
10590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10591 #else
10592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10593 #endif
10594 }
10595 return resultobj;
10596 fail:
10597 return NULL;
10598 }
10599
10600
10601 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10602 PyObject *resultobj = 0;
10603 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10604 wxString result;
10605 void *argp1 = 0 ;
10606 int res1 = 0 ;
10607 PyObject *swig_obj[1] ;
10608
10609 if (!args) SWIG_fail;
10610 swig_obj[0] = args;
10611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10612 if (!SWIG_IsOK(res1)) {
10613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10614 }
10615 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10616 {
10617 PyThreadState* __tstate = wxPyBeginAllowThreads();
10618 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10619 wxPyEndAllowThreads(__tstate);
10620 if (PyErr_Occurred()) SWIG_fail;
10621 }
10622 {
10623 #if wxUSE_UNICODE
10624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10625 #else
10626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10627 #endif
10628 }
10629 return resultobj;
10630 fail:
10631 return NULL;
10632 }
10633
10634
10635 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10636 PyObject *resultobj = 0;
10637 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10638 wxString result;
10639 void *argp1 = 0 ;
10640 int res1 = 0 ;
10641 PyObject *swig_obj[1] ;
10642
10643 if (!args) SWIG_fail;
10644 swig_obj[0] = args;
10645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10646 if (!SWIG_IsOK(res1)) {
10647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10648 }
10649 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10650 {
10651 PyThreadState* __tstate = wxPyBeginAllowThreads();
10652 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10653 wxPyEndAllowThreads(__tstate);
10654 if (PyErr_Occurred()) SWIG_fail;
10655 }
10656 {
10657 #if wxUSE_UNICODE
10658 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10659 #else
10660 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10661 #endif
10662 }
10663 return resultobj;
10664 fail:
10665 return NULL;
10666 }
10667
10668
10669 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10670 PyObject *resultobj = 0;
10671 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10672 wxString result;
10673 void *argp1 = 0 ;
10674 int res1 = 0 ;
10675 PyObject *swig_obj[1] ;
10676
10677 if (!args) SWIG_fail;
10678 swig_obj[0] = args;
10679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10680 if (!SWIG_IsOK(res1)) {
10681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10682 }
10683 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10684 {
10685 PyThreadState* __tstate = wxPyBeginAllowThreads();
10686 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10687 wxPyEndAllowThreads(__tstate);
10688 if (PyErr_Occurred()) SWIG_fail;
10689 }
10690 {
10691 #if wxUSE_UNICODE
10692 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10693 #else
10694 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10695 #endif
10696 }
10697 return resultobj;
10698 fail:
10699 return NULL;
10700 }
10701
10702
10703 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10704 PyObject *resultobj = 0;
10705 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10706 wxString result;
10707 void *argp1 = 0 ;
10708 int res1 = 0 ;
10709 PyObject *swig_obj[1] ;
10710
10711 if (!args) SWIG_fail;
10712 swig_obj[0] = args;
10713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10714 if (!SWIG_IsOK(res1)) {
10715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10716 }
10717 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10718 {
10719 PyThreadState* __tstate = wxPyBeginAllowThreads();
10720 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10721 wxPyEndAllowThreads(__tstate);
10722 if (PyErr_Occurred()) SWIG_fail;
10723 }
10724 {
10725 #if wxUSE_UNICODE
10726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10727 #else
10728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10729 #endif
10730 }
10731 return resultobj;
10732 fail:
10733 return NULL;
10734 }
10735
10736
10737 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10738 PyObject *resultobj = 0;
10739 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10740 wxString result;
10741 void *argp1 = 0 ;
10742 int res1 = 0 ;
10743 PyObject *swig_obj[1] ;
10744
10745 if (!args) SWIG_fail;
10746 swig_obj[0] = args;
10747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10748 if (!SWIG_IsOK(res1)) {
10749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10750 }
10751 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10752 {
10753 PyThreadState* __tstate = wxPyBeginAllowThreads();
10754 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 {
10759 #if wxUSE_UNICODE
10760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10761 #else
10762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10763 #endif
10764 }
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10772 PyObject *resultobj = 0;
10773 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10774 int arg2 ;
10775 int arg3 ;
10776 void *argp1 = 0 ;
10777 int res1 = 0 ;
10778 int val2 ;
10779 int ecode2 = 0 ;
10780 int val3 ;
10781 int ecode3 = 0 ;
10782 PyObject * obj0 = 0 ;
10783 PyObject * obj1 = 0 ;
10784 PyObject * obj2 = 0 ;
10785 char * kwnames[] = {
10786 (char *) "self",(char *) "major",(char *) "minor", NULL
10787 };
10788
10789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10791 if (!SWIG_IsOK(res1)) {
10792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10793 }
10794 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10795 ecode2 = SWIG_AsVal_int(obj1, &val2);
10796 if (!SWIG_IsOK(ecode2)) {
10797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10798 }
10799 arg2 = static_cast< int >(val2);
10800 ecode3 = SWIG_AsVal_int(obj2, &val3);
10801 if (!SWIG_IsOK(ecode3)) {
10802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10803 }
10804 arg3 = static_cast< int >(val3);
10805 {
10806 PyThreadState* __tstate = wxPyBeginAllowThreads();
10807 (arg1)->SetOSVersion(arg2,arg3);
10808 wxPyEndAllowThreads(__tstate);
10809 if (PyErr_Occurred()) SWIG_fail;
10810 }
10811 resultobj = SWIG_Py_Void();
10812 return resultobj;
10813 fail:
10814 return NULL;
10815 }
10816
10817
10818 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10819 PyObject *resultobj = 0;
10820 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10821 int arg2 ;
10822 int arg3 ;
10823 void *argp1 = 0 ;
10824 int res1 = 0 ;
10825 int val2 ;
10826 int ecode2 = 0 ;
10827 int val3 ;
10828 int ecode3 = 0 ;
10829 PyObject * obj0 = 0 ;
10830 PyObject * obj1 = 0 ;
10831 PyObject * obj2 = 0 ;
10832 char * kwnames[] = {
10833 (char *) "self",(char *) "major",(char *) "minor", NULL
10834 };
10835
10836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10838 if (!SWIG_IsOK(res1)) {
10839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10840 }
10841 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10842 ecode2 = SWIG_AsVal_int(obj1, &val2);
10843 if (!SWIG_IsOK(ecode2)) {
10844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10845 }
10846 arg2 = static_cast< int >(val2);
10847 ecode3 = SWIG_AsVal_int(obj2, &val3);
10848 if (!SWIG_IsOK(ecode3)) {
10849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10850 }
10851 arg3 = static_cast< int >(val3);
10852 {
10853 PyThreadState* __tstate = wxPyBeginAllowThreads();
10854 (arg1)->SetToolkitVersion(arg2,arg3);
10855 wxPyEndAllowThreads(__tstate);
10856 if (PyErr_Occurred()) SWIG_fail;
10857 }
10858 resultobj = SWIG_Py_Void();
10859 return resultobj;
10860 fail:
10861 return NULL;
10862 }
10863
10864
10865 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10866 PyObject *resultobj = 0;
10867 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10868 wxOperatingSystemId arg2 ;
10869 void *argp1 = 0 ;
10870 int res1 = 0 ;
10871 int val2 ;
10872 int ecode2 = 0 ;
10873 PyObject * obj0 = 0 ;
10874 PyObject * obj1 = 0 ;
10875 char * kwnames[] = {
10876 (char *) "self",(char *) "n", NULL
10877 };
10878
10879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10881 if (!SWIG_IsOK(res1)) {
10882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10883 }
10884 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10885 ecode2 = SWIG_AsVal_int(obj1, &val2);
10886 if (!SWIG_IsOK(ecode2)) {
10887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10888 }
10889 arg2 = static_cast< wxOperatingSystemId >(val2);
10890 {
10891 PyThreadState* __tstate = wxPyBeginAllowThreads();
10892 (arg1)->SetOperatingSystemId(arg2);
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 resultobj = SWIG_Py_Void();
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj = 0;
10905 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10906 wxPortId arg2 ;
10907 void *argp1 = 0 ;
10908 int res1 = 0 ;
10909 int val2 ;
10910 int ecode2 = 0 ;
10911 PyObject * obj0 = 0 ;
10912 PyObject * obj1 = 0 ;
10913 char * kwnames[] = {
10914 (char *) "self",(char *) "n", NULL
10915 };
10916
10917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10919 if (!SWIG_IsOK(res1)) {
10920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10921 }
10922 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10923 ecode2 = SWIG_AsVal_int(obj1, &val2);
10924 if (!SWIG_IsOK(ecode2)) {
10925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10926 }
10927 arg2 = static_cast< wxPortId >(val2);
10928 {
10929 PyThreadState* __tstate = wxPyBeginAllowThreads();
10930 (arg1)->SetPortId(arg2);
10931 wxPyEndAllowThreads(__tstate);
10932 if (PyErr_Occurred()) SWIG_fail;
10933 }
10934 resultobj = SWIG_Py_Void();
10935 return resultobj;
10936 fail:
10937 return NULL;
10938 }
10939
10940
10941 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10942 PyObject *resultobj = 0;
10943 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10944 wxArchitecture arg2 ;
10945 void *argp1 = 0 ;
10946 int res1 = 0 ;
10947 int val2 ;
10948 int ecode2 = 0 ;
10949 PyObject * obj0 = 0 ;
10950 PyObject * obj1 = 0 ;
10951 char * kwnames[] = {
10952 (char *) "self",(char *) "n", NULL
10953 };
10954
10955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10957 if (!SWIG_IsOK(res1)) {
10958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10959 }
10960 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10961 ecode2 = SWIG_AsVal_int(obj1, &val2);
10962 if (!SWIG_IsOK(ecode2)) {
10963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10964 }
10965 arg2 = static_cast< wxArchitecture >(val2);
10966 {
10967 PyThreadState* __tstate = wxPyBeginAllowThreads();
10968 (arg1)->SetArchitecture(arg2);
10969 wxPyEndAllowThreads(__tstate);
10970 if (PyErr_Occurred()) SWIG_fail;
10971 }
10972 resultobj = SWIG_Py_Void();
10973 return resultobj;
10974 fail:
10975 return NULL;
10976 }
10977
10978
10979 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10980 PyObject *resultobj = 0;
10981 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10982 wxEndianness arg2 ;
10983 void *argp1 = 0 ;
10984 int res1 = 0 ;
10985 int val2 ;
10986 int ecode2 = 0 ;
10987 PyObject * obj0 = 0 ;
10988 PyObject * obj1 = 0 ;
10989 char * kwnames[] = {
10990 (char *) "self",(char *) "n", NULL
10991 };
10992
10993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
10994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10995 if (!SWIG_IsOK(res1)) {
10996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10997 }
10998 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10999 ecode2 = SWIG_AsVal_int(obj1, &val2);
11000 if (!SWIG_IsOK(ecode2)) {
11001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11002 }
11003 arg2 = static_cast< wxEndianness >(val2);
11004 {
11005 PyThreadState* __tstate = wxPyBeginAllowThreads();
11006 (arg1)->SetEndianness(arg2);
11007 wxPyEndAllowThreads(__tstate);
11008 if (PyErr_Occurred()) SWIG_fail;
11009 }
11010 resultobj = SWIG_Py_Void();
11011 return resultobj;
11012 fail:
11013 return NULL;
11014 }
11015
11016
11017 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11018 PyObject *resultobj = 0;
11019 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11020 bool result;
11021 void *argp1 = 0 ;
11022 int res1 = 0 ;
11023 PyObject *swig_obj[1] ;
11024
11025 if (!args) SWIG_fail;
11026 swig_obj[0] = args;
11027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11028 if (!SWIG_IsOK(res1)) {
11029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11030 }
11031 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11032 {
11033 PyThreadState* __tstate = wxPyBeginAllowThreads();
11034 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11035 wxPyEndAllowThreads(__tstate);
11036 if (PyErr_Occurred()) SWIG_fail;
11037 }
11038 {
11039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11040 }
11041 return resultobj;
11042 fail:
11043 return NULL;
11044 }
11045
11046
11047 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11048 PyObject *obj;
11049 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11050 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11051 return SWIG_Py_Void();
11052 }
11053
11054 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11055 return SWIG_Python_InitShadowInstance(args);
11056 }
11057
11058 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11059 PyObject *resultobj = 0;
11060 wxWindow *arg1 = (wxWindow *) 0 ;
11061 wxDC *arg2 = 0 ;
11062 bool result;
11063 void *argp1 = 0 ;
11064 int res1 = 0 ;
11065 void *argp2 = 0 ;
11066 int res2 = 0 ;
11067 PyObject * obj0 = 0 ;
11068 PyObject * obj1 = 0 ;
11069 char * kwnames[] = {
11070 (char *) "window",(char *) "dc", NULL
11071 };
11072
11073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11075 if (!SWIG_IsOK(res1)) {
11076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11077 }
11078 arg1 = reinterpret_cast< wxWindow * >(argp1);
11079 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11080 if (!SWIG_IsOK(res2)) {
11081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11082 }
11083 if (!argp2) {
11084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11085 }
11086 arg2 = reinterpret_cast< wxDC * >(argp2);
11087 {
11088 PyThreadState* __tstate = wxPyBeginAllowThreads();
11089 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11090 wxPyEndAllowThreads(__tstate);
11091 if (PyErr_Occurred()) SWIG_fail;
11092 }
11093 {
11094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11095 }
11096 return resultobj;
11097 fail:
11098 return NULL;
11099 }
11100
11101
11102 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11103 PyObject *resultobj = 0;
11104 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11105 void *argp1 = 0 ;
11106 int res1 = 0 ;
11107 PyObject *swig_obj[1] ;
11108
11109 if (!args) SWIG_fail;
11110 swig_obj[0] = args;
11111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11112 if (!SWIG_IsOK(res1)) {
11113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11114 }
11115 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11116 {
11117 PyThreadState* __tstate = wxPyBeginAllowThreads();
11118 delete arg1;
11119
11120 wxPyEndAllowThreads(__tstate);
11121 if (PyErr_Occurred()) SWIG_fail;
11122 }
11123 resultobj = SWIG_Py_Void();
11124 return resultobj;
11125 fail:
11126 return NULL;
11127 }
11128
11129
11130 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11131 PyObject *resultobj = 0;
11132 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11133 wxString result;
11134 void *argp1 = 0 ;
11135 int res1 = 0 ;
11136 PyObject *swig_obj[1] ;
11137
11138 if (!args) SWIG_fail;
11139 swig_obj[0] = args;
11140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11141 if (!SWIG_IsOK(res1)) {
11142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11143 }
11144 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 result = (arg1)->GetTip();
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 {
11152 #if wxUSE_UNICODE
11153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11154 #else
11155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11156 #endif
11157 }
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11165 PyObject *resultobj = 0;
11166 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11167 size_t result;
11168 void *argp1 = 0 ;
11169 int res1 = 0 ;
11170 PyObject *swig_obj[1] ;
11171
11172 if (!args) SWIG_fail;
11173 swig_obj[0] = args;
11174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11175 if (!SWIG_IsOK(res1)) {
11176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11177 }
11178 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11179 {
11180 PyThreadState* __tstate = wxPyBeginAllowThreads();
11181 result = (size_t)(arg1)->GetCurrentTip();
11182 wxPyEndAllowThreads(__tstate);
11183 if (PyErr_Occurred()) SWIG_fail;
11184 }
11185 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11186 return resultobj;
11187 fail:
11188 return NULL;
11189 }
11190
11191
11192 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11193 PyObject *resultobj = 0;
11194 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11195 wxString *arg2 = 0 ;
11196 wxString result;
11197 void *argp1 = 0 ;
11198 int res1 = 0 ;
11199 bool temp2 = false ;
11200 PyObject * obj0 = 0 ;
11201 PyObject * obj1 = 0 ;
11202 char * kwnames[] = {
11203 (char *) "self",(char *) "tip", NULL
11204 };
11205
11206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11208 if (!SWIG_IsOK(res1)) {
11209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11210 }
11211 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11212 {
11213 arg2 = wxString_in_helper(obj1);
11214 if (arg2 == NULL) SWIG_fail;
11215 temp2 = true;
11216 }
11217 {
11218 PyThreadState* __tstate = wxPyBeginAllowThreads();
11219 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11220 wxPyEndAllowThreads(__tstate);
11221 if (PyErr_Occurred()) SWIG_fail;
11222 }
11223 {
11224 #if wxUSE_UNICODE
11225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11226 #else
11227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11228 #endif
11229 }
11230 {
11231 if (temp2)
11232 delete arg2;
11233 }
11234 return resultobj;
11235 fail:
11236 {
11237 if (temp2)
11238 delete arg2;
11239 }
11240 return NULL;
11241 }
11242
11243
11244 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11245 PyObject *obj;
11246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11247 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11248 return SWIG_Py_Void();
11249 }
11250
11251 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11252 PyObject *resultobj = 0;
11253 size_t arg1 ;
11254 wxPyTipProvider *result = 0 ;
11255 size_t val1 ;
11256 int ecode1 = 0 ;
11257 PyObject * obj0 = 0 ;
11258 char * kwnames[] = {
11259 (char *) "currentTip", NULL
11260 };
11261
11262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11263 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11264 if (!SWIG_IsOK(ecode1)) {
11265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11266 }
11267 arg1 = static_cast< size_t >(val1);
11268 {
11269 PyThreadState* __tstate = wxPyBeginAllowThreads();
11270 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11271 wxPyEndAllowThreads(__tstate);
11272 if (PyErr_Occurred()) SWIG_fail;
11273 }
11274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11275 return resultobj;
11276 fail:
11277 return NULL;
11278 }
11279
11280
11281 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11282 PyObject *resultobj = 0;
11283 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11284 PyObject *arg2 = (PyObject *) 0 ;
11285 PyObject *arg3 = (PyObject *) 0 ;
11286 void *argp1 = 0 ;
11287 int res1 = 0 ;
11288 PyObject * obj0 = 0 ;
11289 PyObject * obj1 = 0 ;
11290 PyObject * obj2 = 0 ;
11291 char * kwnames[] = {
11292 (char *) "self",(char *) "self",(char *) "_class", NULL
11293 };
11294
11295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11297 if (!SWIG_IsOK(res1)) {
11298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11299 }
11300 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11301 arg2 = obj1;
11302 arg3 = obj2;
11303 {
11304 PyThreadState* __tstate = wxPyBeginAllowThreads();
11305 (arg1)->_setCallbackInfo(arg2,arg3);
11306 wxPyEndAllowThreads(__tstate);
11307 if (PyErr_Occurred()) SWIG_fail;
11308 }
11309 resultobj = SWIG_Py_Void();
11310 return resultobj;
11311 fail:
11312 return NULL;
11313 }
11314
11315
11316 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11317 PyObject *obj;
11318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11319 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11320 return SWIG_Py_Void();
11321 }
11322
11323 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11324 return SWIG_Python_InitShadowInstance(args);
11325 }
11326
11327 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj = 0;
11329 wxWindow *arg1 = (wxWindow *) 0 ;
11330 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11331 bool arg3 = (bool) true ;
11332 bool result;
11333 void *argp1 = 0 ;
11334 int res1 = 0 ;
11335 void *argp2 = 0 ;
11336 int res2 = 0 ;
11337 bool val3 ;
11338 int ecode3 = 0 ;
11339 PyObject * obj0 = 0 ;
11340 PyObject * obj1 = 0 ;
11341 PyObject * obj2 = 0 ;
11342 char * kwnames[] = {
11343 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11344 };
11345
11346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11348 if (!SWIG_IsOK(res1)) {
11349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11350 }
11351 arg1 = reinterpret_cast< wxWindow * >(argp1);
11352 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11353 if (!SWIG_IsOK(res2)) {
11354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11355 }
11356 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11357 if (obj2) {
11358 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11359 if (!SWIG_IsOK(ecode3)) {
11360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11361 }
11362 arg3 = static_cast< bool >(val3);
11363 }
11364 {
11365 if (!wxPyCheckForApp()) SWIG_fail;
11366 PyThreadState* __tstate = wxPyBeginAllowThreads();
11367 result = (bool)wxShowTip(arg1,arg2,arg3);
11368 wxPyEndAllowThreads(__tstate);
11369 if (PyErr_Occurred()) SWIG_fail;
11370 }
11371 {
11372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11373 }
11374 return resultobj;
11375 fail:
11376 return NULL;
11377 }
11378
11379
11380 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11381 PyObject *resultobj = 0;
11382 wxString *arg1 = 0 ;
11383 size_t arg2 ;
11384 wxTipProvider *result = 0 ;
11385 bool temp1 = false ;
11386 size_t val2 ;
11387 int ecode2 = 0 ;
11388 PyObject * obj0 = 0 ;
11389 PyObject * obj1 = 0 ;
11390 char * kwnames[] = {
11391 (char *) "filename",(char *) "currentTip", NULL
11392 };
11393
11394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11395 {
11396 arg1 = wxString_in_helper(obj0);
11397 if (arg1 == NULL) SWIG_fail;
11398 temp1 = true;
11399 }
11400 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11401 if (!SWIG_IsOK(ecode2)) {
11402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11403 }
11404 arg2 = static_cast< size_t >(val2);
11405 {
11406 if (!wxPyCheckForApp()) SWIG_fail;
11407 PyThreadState* __tstate = wxPyBeginAllowThreads();
11408 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11409 wxPyEndAllowThreads(__tstate);
11410 if (PyErr_Occurred()) SWIG_fail;
11411 }
11412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11413 {
11414 if (temp1)
11415 delete arg1;
11416 }
11417 return resultobj;
11418 fail:
11419 {
11420 if (temp1)
11421 delete arg1;
11422 }
11423 return NULL;
11424 }
11425
11426
11427 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11428 PyObject *resultobj = 0;
11429 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11430 int arg2 = (int) wxID_ANY ;
11431 wxPyTimer *result = 0 ;
11432 void *argp1 = 0 ;
11433 int res1 = 0 ;
11434 int val2 ;
11435 int ecode2 = 0 ;
11436 PyObject * obj0 = 0 ;
11437 PyObject * obj1 = 0 ;
11438 char * kwnames[] = {
11439 (char *) "owner",(char *) "id", NULL
11440 };
11441
11442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11443 if (obj0) {
11444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11445 if (!SWIG_IsOK(res1)) {
11446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11447 }
11448 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11449 }
11450 if (obj1) {
11451 ecode2 = SWIG_AsVal_int(obj1, &val2);
11452 if (!SWIG_IsOK(ecode2)) {
11453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11454 }
11455 arg2 = static_cast< int >(val2);
11456 }
11457 {
11458 if (!wxPyCheckForApp()) SWIG_fail;
11459 PyThreadState* __tstate = wxPyBeginAllowThreads();
11460 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11461 wxPyEndAllowThreads(__tstate);
11462 if (PyErr_Occurred()) SWIG_fail;
11463 }
11464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11465 return resultobj;
11466 fail:
11467 return NULL;
11468 }
11469
11470
11471 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11472 PyObject *resultobj = 0;
11473 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11474 void *argp1 = 0 ;
11475 int res1 = 0 ;
11476 PyObject *swig_obj[1] ;
11477
11478 if (!args) SWIG_fail;
11479 swig_obj[0] = args;
11480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11481 if (!SWIG_IsOK(res1)) {
11482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11483 }
11484 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 delete arg1;
11488
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 resultobj = SWIG_Py_Void();
11493 return resultobj;
11494 fail:
11495 return NULL;
11496 }
11497
11498
11499 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj = 0;
11501 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11502 PyObject *arg2 = (PyObject *) 0 ;
11503 PyObject *arg3 = (PyObject *) 0 ;
11504 int arg4 = (int) 0 ;
11505 void *argp1 = 0 ;
11506 int res1 = 0 ;
11507 int val4 ;
11508 int ecode4 = 0 ;
11509 PyObject * obj0 = 0 ;
11510 PyObject * obj1 = 0 ;
11511 PyObject * obj2 = 0 ;
11512 PyObject * obj3 = 0 ;
11513 char * kwnames[] = {
11514 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11515 };
11516
11517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11521 }
11522 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11523 arg2 = obj1;
11524 arg3 = obj2;
11525 if (obj3) {
11526 ecode4 = SWIG_AsVal_int(obj3, &val4);
11527 if (!SWIG_IsOK(ecode4)) {
11528 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11529 }
11530 arg4 = static_cast< int >(val4);
11531 }
11532 {
11533 PyThreadState* __tstate = wxPyBeginAllowThreads();
11534 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11535 wxPyEndAllowThreads(__tstate);
11536 if (PyErr_Occurred()) SWIG_fail;
11537 }
11538 resultobj = SWIG_Py_Void();
11539 return resultobj;
11540 fail:
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11546 PyObject *resultobj = 0;
11547 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11548 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11549 int arg3 = (int) wxID_ANY ;
11550 void *argp1 = 0 ;
11551 int res1 = 0 ;
11552 void *argp2 = 0 ;
11553 int res2 = 0 ;
11554 int val3 ;
11555 int ecode3 = 0 ;
11556 PyObject * obj0 = 0 ;
11557 PyObject * obj1 = 0 ;
11558 PyObject * obj2 = 0 ;
11559 char * kwnames[] = {
11560 (char *) "self",(char *) "owner",(char *) "id", NULL
11561 };
11562
11563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11565 if (!SWIG_IsOK(res1)) {
11566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11567 }
11568 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11570 if (!SWIG_IsOK(res2)) {
11571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11572 }
11573 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11574 if (obj2) {
11575 ecode3 = SWIG_AsVal_int(obj2, &val3);
11576 if (!SWIG_IsOK(ecode3)) {
11577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11578 }
11579 arg3 = static_cast< int >(val3);
11580 }
11581 {
11582 PyThreadState* __tstate = wxPyBeginAllowThreads();
11583 (arg1)->SetOwner(arg2,arg3);
11584 wxPyEndAllowThreads(__tstate);
11585 if (PyErr_Occurred()) SWIG_fail;
11586 }
11587 resultobj = SWIG_Py_Void();
11588 return resultobj;
11589 fail:
11590 return NULL;
11591 }
11592
11593
11594 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11595 PyObject *resultobj = 0;
11596 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11597 wxEvtHandler *result = 0 ;
11598 void *argp1 = 0 ;
11599 int res1 = 0 ;
11600 PyObject *swig_obj[1] ;
11601
11602 if (!args) SWIG_fail;
11603 swig_obj[0] = args;
11604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11605 if (!SWIG_IsOK(res1)) {
11606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11607 }
11608 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 result = (wxEvtHandler *)(arg1)->GetOwner();
11612 wxPyEndAllowThreads(__tstate);
11613 if (PyErr_Occurred()) SWIG_fail;
11614 }
11615 {
11616 resultobj = wxPyMake_wxObject(result, 0);
11617 }
11618 return resultobj;
11619 fail:
11620 return NULL;
11621 }
11622
11623
11624 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11625 PyObject *resultobj = 0;
11626 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11627 int arg2 = (int) -1 ;
11628 bool arg3 = (bool) false ;
11629 bool result;
11630 void *argp1 = 0 ;
11631 int res1 = 0 ;
11632 int val2 ;
11633 int ecode2 = 0 ;
11634 bool val3 ;
11635 int ecode3 = 0 ;
11636 PyObject * obj0 = 0 ;
11637 PyObject * obj1 = 0 ;
11638 PyObject * obj2 = 0 ;
11639 char * kwnames[] = {
11640 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11641 };
11642
11643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11645 if (!SWIG_IsOK(res1)) {
11646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11647 }
11648 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11649 if (obj1) {
11650 ecode2 = SWIG_AsVal_int(obj1, &val2);
11651 if (!SWIG_IsOK(ecode2)) {
11652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11653 }
11654 arg2 = static_cast< int >(val2);
11655 }
11656 if (obj2) {
11657 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11658 if (!SWIG_IsOK(ecode3)) {
11659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11660 }
11661 arg3 = static_cast< bool >(val3);
11662 }
11663 {
11664 PyThreadState* __tstate = wxPyBeginAllowThreads();
11665 result = (bool)(arg1)->Start(arg2,arg3);
11666 wxPyEndAllowThreads(__tstate);
11667 if (PyErr_Occurred()) SWIG_fail;
11668 }
11669 {
11670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11671 }
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11679 PyObject *resultobj = 0;
11680 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11681 void *argp1 = 0 ;
11682 int res1 = 0 ;
11683 PyObject *swig_obj[1] ;
11684
11685 if (!args) SWIG_fail;
11686 swig_obj[0] = args;
11687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11688 if (!SWIG_IsOK(res1)) {
11689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11690 }
11691 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11692 {
11693 PyThreadState* __tstate = wxPyBeginAllowThreads();
11694 (arg1)->Stop();
11695 wxPyEndAllowThreads(__tstate);
11696 if (PyErr_Occurred()) SWIG_fail;
11697 }
11698 resultobj = SWIG_Py_Void();
11699 return resultobj;
11700 fail:
11701 return NULL;
11702 }
11703
11704
11705 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11706 PyObject *resultobj = 0;
11707 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11708 void *argp1 = 0 ;
11709 int res1 = 0 ;
11710 PyObject *swig_obj[1] ;
11711
11712 if (!args) SWIG_fail;
11713 swig_obj[0] = args;
11714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11715 if (!SWIG_IsOK(res1)) {
11716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11717 }
11718 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11719 {
11720 PyThreadState* __tstate = wxPyBeginAllowThreads();
11721 (arg1)->Notify();
11722 wxPyEndAllowThreads(__tstate);
11723 if (PyErr_Occurred()) SWIG_fail;
11724 }
11725 resultobj = SWIG_Py_Void();
11726 return resultobj;
11727 fail:
11728 return NULL;
11729 }
11730
11731
11732 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11733 PyObject *resultobj = 0;
11734 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11735 bool result;
11736 void *argp1 = 0 ;
11737 int res1 = 0 ;
11738 PyObject *swig_obj[1] ;
11739
11740 if (!args) SWIG_fail;
11741 swig_obj[0] = args;
11742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11743 if (!SWIG_IsOK(res1)) {
11744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11745 }
11746 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11747 {
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 {
11754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11755 }
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11763 PyObject *resultobj = 0;
11764 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11765 int 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_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11775 }
11776 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11777 {
11778 PyThreadState* __tstate = wxPyBeginAllowThreads();
11779 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11780 wxPyEndAllowThreads(__tstate);
11781 if (PyErr_Occurred()) SWIG_fail;
11782 }
11783 resultobj = SWIG_From_int(static_cast< int >(result));
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11791 PyObject *resultobj = 0;
11792 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11793 int result;
11794 void *argp1 = 0 ;
11795 int res1 = 0 ;
11796 PyObject *swig_obj[1] ;
11797
11798 if (!args) SWIG_fail;
11799 swig_obj[0] = args;
11800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11801 if (!SWIG_IsOK(res1)) {
11802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11803 }
11804 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11805 {
11806 PyThreadState* __tstate = wxPyBeginAllowThreads();
11807 result = (int)((wxPyTimer const *)arg1)->GetId();
11808 wxPyEndAllowThreads(__tstate);
11809 if (PyErr_Occurred()) SWIG_fail;
11810 }
11811 resultobj = SWIG_From_int(static_cast< int >(result));
11812 return resultobj;
11813 fail:
11814 return NULL;
11815 }
11816
11817
11818 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11819 PyObject *resultobj = 0;
11820 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11821 bool result;
11822 void *argp1 = 0 ;
11823 int res1 = 0 ;
11824 PyObject *swig_obj[1] ;
11825
11826 if (!args) SWIG_fail;
11827 swig_obj[0] = args;
11828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11829 if (!SWIG_IsOK(res1)) {
11830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11831 }
11832 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11836 wxPyEndAllowThreads(__tstate);
11837 if (PyErr_Occurred()) SWIG_fail;
11838 }
11839 {
11840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11841 }
11842 return resultobj;
11843 fail:
11844 return NULL;
11845 }
11846
11847
11848 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11849 PyObject *obj;
11850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11851 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11852 return SWIG_Py_Void();
11853 }
11854
11855 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11856 return SWIG_Python_InitShadowInstance(args);
11857 }
11858
11859 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj = 0;
11861 int arg1 = (int) 0 ;
11862 int arg2 = (int) 0 ;
11863 wxTimerEvent *result = 0 ;
11864 int val1 ;
11865 int ecode1 = 0 ;
11866 int val2 ;
11867 int ecode2 = 0 ;
11868 PyObject * obj0 = 0 ;
11869 PyObject * obj1 = 0 ;
11870 char * kwnames[] = {
11871 (char *) "timerid",(char *) "interval", NULL
11872 };
11873
11874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11875 if (obj0) {
11876 ecode1 = SWIG_AsVal_int(obj0, &val1);
11877 if (!SWIG_IsOK(ecode1)) {
11878 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11879 }
11880 arg1 = static_cast< int >(val1);
11881 }
11882 if (obj1) {
11883 ecode2 = SWIG_AsVal_int(obj1, &val2);
11884 if (!SWIG_IsOK(ecode2)) {
11885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11886 }
11887 arg2 = static_cast< int >(val2);
11888 }
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11896 return resultobj;
11897 fail:
11898 return NULL;
11899 }
11900
11901
11902 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11903 PyObject *resultobj = 0;
11904 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11905 int result;
11906 void *argp1 = 0 ;
11907 int res1 = 0 ;
11908 PyObject *swig_obj[1] ;
11909
11910 if (!args) SWIG_fail;
11911 swig_obj[0] = args;
11912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11913 if (!SWIG_IsOK(res1)) {
11914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11915 }
11916 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11920 wxPyEndAllowThreads(__tstate);
11921 if (PyErr_Occurred()) SWIG_fail;
11922 }
11923 resultobj = SWIG_From_int(static_cast< int >(result));
11924 return resultobj;
11925 fail:
11926 return NULL;
11927 }
11928
11929
11930 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11931 PyObject *obj;
11932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11933 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11934 return SWIG_Py_Void();
11935 }
11936
11937 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11938 return SWIG_Python_InitShadowInstance(args);
11939 }
11940
11941 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11942 PyObject *resultobj = 0;
11943 wxTimer *arg1 = 0 ;
11944 wxTimerRunner *result = 0 ;
11945 void *argp1 = 0 ;
11946 int res1 = 0 ;
11947
11948 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11950 if (!SWIG_IsOK(res1)) {
11951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11952 }
11953 if (!argp1) {
11954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11955 }
11956 arg1 = reinterpret_cast< wxTimer * >(argp1);
11957 {
11958 if (!wxPyCheckForApp()) SWIG_fail;
11959 PyThreadState* __tstate = wxPyBeginAllowThreads();
11960 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11961 wxPyEndAllowThreads(__tstate);
11962 if (PyErr_Occurred()) SWIG_fail;
11963 }
11964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11965 return resultobj;
11966 fail:
11967 return NULL;
11968 }
11969
11970
11971 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11972 PyObject *resultobj = 0;
11973 wxTimer *arg1 = 0 ;
11974 int arg2 ;
11975 bool arg3 = (bool) false ;
11976 wxTimerRunner *result = 0 ;
11977 void *argp1 = 0 ;
11978 int res1 = 0 ;
11979 int val2 ;
11980 int ecode2 = 0 ;
11981 bool val3 ;
11982 int ecode3 = 0 ;
11983
11984 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11986 if (!SWIG_IsOK(res1)) {
11987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11988 }
11989 if (!argp1) {
11990 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11991 }
11992 arg1 = reinterpret_cast< wxTimer * >(argp1);
11993 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11994 if (!SWIG_IsOK(ecode2)) {
11995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
11996 }
11997 arg2 = static_cast< int >(val2);
11998 if (swig_obj[2]) {
11999 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12000 if (!SWIG_IsOK(ecode3)) {
12001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12002 }
12003 arg3 = static_cast< bool >(val3);
12004 }
12005 {
12006 if (!wxPyCheckForApp()) SWIG_fail;
12007 PyThreadState* __tstate = wxPyBeginAllowThreads();
12008 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12020 int argc;
12021 PyObject *argv[4];
12022
12023 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12024 --argc;
12025 if (argc == 1) {
12026 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12027 }
12028 if ((argc >= 2) && (argc <= 3)) {
12029 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12030 }
12031
12032 fail:
12033 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12034 return NULL;
12035 }
12036
12037
12038 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12039 PyObject *resultobj = 0;
12040 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12041 void *argp1 = 0 ;
12042 int res1 = 0 ;
12043 PyObject *swig_obj[1] ;
12044
12045 if (!args) SWIG_fail;
12046 swig_obj[0] = args;
12047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12048 if (!SWIG_IsOK(res1)) {
12049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12050 }
12051 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12052 {
12053 PyThreadState* __tstate = wxPyBeginAllowThreads();
12054 delete arg1;
12055
12056 wxPyEndAllowThreads(__tstate);
12057 if (PyErr_Occurred()) SWIG_fail;
12058 }
12059 resultobj = SWIG_Py_Void();
12060 return resultobj;
12061 fail:
12062 return NULL;
12063 }
12064
12065
12066 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12067 PyObject *resultobj = 0;
12068 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12069 int arg2 ;
12070 bool arg3 = (bool) false ;
12071 void *argp1 = 0 ;
12072 int res1 = 0 ;
12073 int val2 ;
12074 int ecode2 = 0 ;
12075 bool val3 ;
12076 int ecode3 = 0 ;
12077 PyObject * obj0 = 0 ;
12078 PyObject * obj1 = 0 ;
12079 PyObject * obj2 = 0 ;
12080 char * kwnames[] = {
12081 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12082 };
12083
12084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12086 if (!SWIG_IsOK(res1)) {
12087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12088 }
12089 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12090 ecode2 = SWIG_AsVal_int(obj1, &val2);
12091 if (!SWIG_IsOK(ecode2)) {
12092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12093 }
12094 arg2 = static_cast< int >(val2);
12095 if (obj2) {
12096 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12097 if (!SWIG_IsOK(ecode3)) {
12098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12099 }
12100 arg3 = static_cast< bool >(val3);
12101 }
12102 {
12103 PyThreadState* __tstate = wxPyBeginAllowThreads();
12104 (arg1)->Start(arg2,arg3);
12105 wxPyEndAllowThreads(__tstate);
12106 if (PyErr_Occurred()) SWIG_fail;
12107 }
12108 resultobj = SWIG_Py_Void();
12109 return resultobj;
12110 fail:
12111 return NULL;
12112 }
12113
12114
12115 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12116 PyObject *obj;
12117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12118 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12119 return SWIG_Py_Void();
12120 }
12121
12122 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12123 return SWIG_Python_InitShadowInstance(args);
12124 }
12125
12126 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12127 PyObject *resultobj = 0;
12128 wxLog *result = 0 ;
12129
12130 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 result = (wxLog *)new wxLog();
12134 wxPyEndAllowThreads(__tstate);
12135 if (PyErr_Occurred()) SWIG_fail;
12136 }
12137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 PyObject *resultobj = 0;
12146 wxLog *arg1 = (wxLog *) 0 ;
12147 void *argp1 = 0 ;
12148 int res1 = 0 ;
12149 PyObject *swig_obj[1] ;
12150
12151 if (!args) SWIG_fail;
12152 swig_obj[0] = args;
12153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12154 if (!SWIG_IsOK(res1)) {
12155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12156 }
12157 arg1 = reinterpret_cast< wxLog * >(argp1);
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 delete arg1;
12161
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 resultobj = SWIG_Py_Void();
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12173 PyObject *resultobj = 0;
12174 bool result;
12175
12176 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12177 {
12178 PyThreadState* __tstate = wxPyBeginAllowThreads();
12179 result = (bool)wxLog::IsEnabled();
12180 wxPyEndAllowThreads(__tstate);
12181 if (PyErr_Occurred()) SWIG_fail;
12182 }
12183 {
12184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12185 }
12186 return resultobj;
12187 fail:
12188 return NULL;
12189 }
12190
12191
12192 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12193 PyObject *resultobj = 0;
12194 bool arg1 = (bool) true ;
12195 bool result;
12196 bool val1 ;
12197 int ecode1 = 0 ;
12198 PyObject * obj0 = 0 ;
12199 char * kwnames[] = {
12200 (char *) "doIt", NULL
12201 };
12202
12203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12204 if (obj0) {
12205 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12206 if (!SWIG_IsOK(ecode1)) {
12207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12208 }
12209 arg1 = static_cast< bool >(val1);
12210 }
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 result = (bool)wxLog::EnableLogging(arg1);
12214 wxPyEndAllowThreads(__tstate);
12215 if (PyErr_Occurred()) SWIG_fail;
12216 }
12217 {
12218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12219 }
12220 return resultobj;
12221 fail:
12222 return NULL;
12223 }
12224
12225
12226 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12227 PyObject *resultobj = 0;
12228 wxLogLevel arg1 ;
12229 wxChar *arg2 = (wxChar *) 0 ;
12230 time_t arg3 ;
12231 unsigned long val1 ;
12232 int ecode1 = 0 ;
12233 void *argp2 = 0 ;
12234 int res2 = 0 ;
12235 unsigned int val3 ;
12236 int ecode3 = 0 ;
12237 PyObject * obj0 = 0 ;
12238 PyObject * obj1 = 0 ;
12239 PyObject * obj2 = 0 ;
12240 char * kwnames[] = {
12241 (char *) "level",(char *) "szString",(char *) "t", NULL
12242 };
12243
12244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12245 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12246 if (!SWIG_IsOK(ecode1)) {
12247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12248 }
12249 arg1 = static_cast< wxLogLevel >(val1);
12250 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12251 if (!SWIG_IsOK(res2)) {
12252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12253 }
12254 arg2 = reinterpret_cast< wxChar * >(argp2);
12255 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12256 if (!SWIG_IsOK(ecode3)) {
12257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12258 }
12259 arg3 = static_cast< time_t >(val3);
12260 {
12261 PyThreadState* __tstate = wxPyBeginAllowThreads();
12262 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12263 wxPyEndAllowThreads(__tstate);
12264 if (PyErr_Occurred()) SWIG_fail;
12265 }
12266 resultobj = SWIG_Py_Void();
12267 return resultobj;
12268 fail:
12269 return NULL;
12270 }
12271
12272
12273 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12274 PyObject *resultobj = 0;
12275 wxLog *arg1 = (wxLog *) 0 ;
12276 void *argp1 = 0 ;
12277 int res1 = 0 ;
12278 PyObject *swig_obj[1] ;
12279
12280 if (!args) SWIG_fail;
12281 swig_obj[0] = args;
12282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12283 if (!SWIG_IsOK(res1)) {
12284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12285 }
12286 arg1 = reinterpret_cast< wxLog * >(argp1);
12287 {
12288 PyThreadState* __tstate = wxPyBeginAllowThreads();
12289 (arg1)->Flush();
12290 wxPyEndAllowThreads(__tstate);
12291 if (PyErr_Occurred()) SWIG_fail;
12292 }
12293 resultobj = SWIG_Py_Void();
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12301 PyObject *resultobj = 0;
12302
12303 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 wxLog::FlushActive();
12307 wxPyEndAllowThreads(__tstate);
12308 if (PyErr_Occurred()) SWIG_fail;
12309 }
12310 resultobj = SWIG_Py_Void();
12311 return resultobj;
12312 fail:
12313 return NULL;
12314 }
12315
12316
12317 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12318 PyObject *resultobj = 0;
12319 wxLog *result = 0 ;
12320
12321 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12322 {
12323 PyThreadState* __tstate = wxPyBeginAllowThreads();
12324 result = (wxLog *)wxLog::GetActiveTarget();
12325 wxPyEndAllowThreads(__tstate);
12326 if (PyErr_Occurred()) SWIG_fail;
12327 }
12328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12329 return resultobj;
12330 fail:
12331 return NULL;
12332 }
12333
12334
12335 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12336 PyObject *resultobj = 0;
12337 wxLog *arg1 = (wxLog *) 0 ;
12338 wxLog *result = 0 ;
12339 int res1 = 0 ;
12340 PyObject * obj0 = 0 ;
12341 char * kwnames[] = {
12342 (char *) "pLogger", NULL
12343 };
12344
12345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12346 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12347 if (!SWIG_IsOK(res1)) {
12348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12349 }
12350 {
12351 PyThreadState* __tstate = wxPyBeginAllowThreads();
12352 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12353 wxPyEndAllowThreads(__tstate);
12354 if (PyErr_Occurred()) SWIG_fail;
12355 }
12356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12357 return resultobj;
12358 fail:
12359 return NULL;
12360 }
12361
12362
12363 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12364 PyObject *resultobj = 0;
12365
12366 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 wxLog::Suspend();
12370 wxPyEndAllowThreads(__tstate);
12371 if (PyErr_Occurred()) SWIG_fail;
12372 }
12373 resultobj = SWIG_Py_Void();
12374 return resultobj;
12375 fail:
12376 return NULL;
12377 }
12378
12379
12380 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12381 PyObject *resultobj = 0;
12382
12383 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 wxLog::Resume();
12387 wxPyEndAllowThreads(__tstate);
12388 if (PyErr_Occurred()) SWIG_fail;
12389 }
12390 resultobj = SWIG_Py_Void();
12391 return resultobj;
12392 fail:
12393 return NULL;
12394 }
12395
12396
12397 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12398 PyObject *resultobj = 0;
12399 bool arg1 = (bool) true ;
12400 bool val1 ;
12401 int ecode1 = 0 ;
12402 PyObject * obj0 = 0 ;
12403 char * kwnames[] = {
12404 (char *) "bVerbose", NULL
12405 };
12406
12407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12408 if (obj0) {
12409 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12410 if (!SWIG_IsOK(ecode1)) {
12411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12412 }
12413 arg1 = static_cast< bool >(val1);
12414 }
12415 {
12416 PyThreadState* __tstate = wxPyBeginAllowThreads();
12417 wxLog::SetVerbose(arg1);
12418 wxPyEndAllowThreads(__tstate);
12419 if (PyErr_Occurred()) SWIG_fail;
12420 }
12421 resultobj = SWIG_Py_Void();
12422 return resultobj;
12423 fail:
12424 return NULL;
12425 }
12426
12427
12428 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12429 PyObject *resultobj = 0;
12430 wxLogLevel arg1 ;
12431 unsigned long val1 ;
12432 int ecode1 = 0 ;
12433 PyObject * obj0 = 0 ;
12434 char * kwnames[] = {
12435 (char *) "logLevel", NULL
12436 };
12437
12438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12439 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12440 if (!SWIG_IsOK(ecode1)) {
12441 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12442 }
12443 arg1 = static_cast< wxLogLevel >(val1);
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 wxLog::SetLogLevel(arg1);
12447 wxPyEndAllowThreads(__tstate);
12448 if (PyErr_Occurred()) SWIG_fail;
12449 }
12450 resultobj = SWIG_Py_Void();
12451 return resultobj;
12452 fail:
12453 return NULL;
12454 }
12455
12456
12457 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12458 PyObject *resultobj = 0;
12459
12460 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12461 {
12462 PyThreadState* __tstate = wxPyBeginAllowThreads();
12463 wxLog::DontCreateOnDemand();
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 resultobj = SWIG_Py_Void();
12468 return resultobj;
12469 fail:
12470 return NULL;
12471 }
12472
12473
12474 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12475 PyObject *resultobj = 0;
12476 bool arg1 = (bool) true ;
12477 bool val1 ;
12478 int ecode1 = 0 ;
12479 PyObject * obj0 = 0 ;
12480 char * kwnames[] = {
12481 (char *) "bRepetCounting", NULL
12482 };
12483
12484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12485 if (obj0) {
12486 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12487 if (!SWIG_IsOK(ecode1)) {
12488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12489 }
12490 arg1 = static_cast< bool >(val1);
12491 }
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 wxLog::SetRepetitionCounting(arg1);
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 resultobj = SWIG_Py_Void();
12499 return resultobj;
12500 fail:
12501 return NULL;
12502 }
12503
12504
12505 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12506 PyObject *resultobj = 0;
12507 bool result;
12508
12509 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12510 {
12511 PyThreadState* __tstate = wxPyBeginAllowThreads();
12512 result = (bool)wxLog::GetRepetitionCounting();
12513 wxPyEndAllowThreads(__tstate);
12514 if (PyErr_Occurred()) SWIG_fail;
12515 }
12516 {
12517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12518 }
12519 return resultobj;
12520 fail:
12521 return NULL;
12522 }
12523
12524
12525 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12526 PyObject *resultobj = 0;
12527 wxTraceMask arg1 ;
12528 unsigned long val1 ;
12529 int ecode1 = 0 ;
12530 PyObject * obj0 = 0 ;
12531 char * kwnames[] = {
12532 (char *) "ulMask", NULL
12533 };
12534
12535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12536 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12537 if (!SWIG_IsOK(ecode1)) {
12538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12539 }
12540 arg1 = static_cast< wxTraceMask >(val1);
12541 {
12542 PyThreadState* __tstate = wxPyBeginAllowThreads();
12543 wxLog::SetTraceMask(arg1);
12544 wxPyEndAllowThreads(__tstate);
12545 if (PyErr_Occurred()) SWIG_fail;
12546 }
12547 resultobj = SWIG_Py_Void();
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12555 PyObject *resultobj = 0;
12556 wxString *arg1 = 0 ;
12557 bool temp1 = false ;
12558 PyObject * obj0 = 0 ;
12559 char * kwnames[] = {
12560 (char *) "str", NULL
12561 };
12562
12563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12564 {
12565 arg1 = wxString_in_helper(obj0);
12566 if (arg1 == NULL) SWIG_fail;
12567 temp1 = true;
12568 }
12569 {
12570 PyThreadState* __tstate = wxPyBeginAllowThreads();
12571 wxLog::AddTraceMask((wxString const &)*arg1);
12572 wxPyEndAllowThreads(__tstate);
12573 if (PyErr_Occurred()) SWIG_fail;
12574 }
12575 resultobj = SWIG_Py_Void();
12576 {
12577 if (temp1)
12578 delete arg1;
12579 }
12580 return resultobj;
12581 fail:
12582 {
12583 if (temp1)
12584 delete arg1;
12585 }
12586 return NULL;
12587 }
12588
12589
12590 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12591 PyObject *resultobj = 0;
12592 wxString *arg1 = 0 ;
12593 bool temp1 = false ;
12594 PyObject * obj0 = 0 ;
12595 char * kwnames[] = {
12596 (char *) "str", NULL
12597 };
12598
12599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12600 {
12601 arg1 = wxString_in_helper(obj0);
12602 if (arg1 == NULL) SWIG_fail;
12603 temp1 = true;
12604 }
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 wxLog::RemoveTraceMask((wxString const &)*arg1);
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 resultobj = SWIG_Py_Void();
12612 {
12613 if (temp1)
12614 delete arg1;
12615 }
12616 return resultobj;
12617 fail:
12618 {
12619 if (temp1)
12620 delete arg1;
12621 }
12622 return NULL;
12623 }
12624
12625
12626 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12627 PyObject *resultobj = 0;
12628
12629 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12630 {
12631 PyThreadState* __tstate = wxPyBeginAllowThreads();
12632 wxLog::ClearTraceMasks();
12633 wxPyEndAllowThreads(__tstate);
12634 if (PyErr_Occurred()) SWIG_fail;
12635 }
12636 resultobj = SWIG_Py_Void();
12637 return resultobj;
12638 fail:
12639 return NULL;
12640 }
12641
12642
12643 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12644 PyObject *resultobj = 0;
12645 wxArrayString *result = 0 ;
12646
12647 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12648 {
12649 PyThreadState* __tstate = wxPyBeginAllowThreads();
12650 {
12651 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12652 result = (wxArrayString *) &_result_ref;
12653 }
12654 wxPyEndAllowThreads(__tstate);
12655 if (PyErr_Occurred()) SWIG_fail;
12656 }
12657 {
12658 resultobj = wxArrayString2PyList_helper(*result);
12659 }
12660 return resultobj;
12661 fail:
12662 return NULL;
12663 }
12664
12665
12666 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj = 0;
12668 wxChar *arg1 = (wxChar *) 0 ;
12669 void *argp1 = 0 ;
12670 int res1 = 0 ;
12671 PyObject * obj0 = 0 ;
12672 char * kwnames[] = {
12673 (char *) "ts", NULL
12674 };
12675
12676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12678 if (!SWIG_IsOK(res1)) {
12679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12680 }
12681 arg1 = reinterpret_cast< wxChar * >(argp1);
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 wxLog::SetTimestamp((wxChar const *)arg1);
12685 wxPyEndAllowThreads(__tstate);
12686 if (PyErr_Occurred()) SWIG_fail;
12687 }
12688 resultobj = SWIG_Py_Void();
12689 return resultobj;
12690 fail:
12691 return NULL;
12692 }
12693
12694
12695 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12696 PyObject *resultobj = 0;
12697 bool result;
12698
12699 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12700 {
12701 PyThreadState* __tstate = wxPyBeginAllowThreads();
12702 result = (bool)wxLog::GetVerbose();
12703 wxPyEndAllowThreads(__tstate);
12704 if (PyErr_Occurred()) SWIG_fail;
12705 }
12706 {
12707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12708 }
12709 return resultobj;
12710 fail:
12711 return NULL;
12712 }
12713
12714
12715 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12716 PyObject *resultobj = 0;
12717 wxTraceMask result;
12718
12719 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12720 {
12721 PyThreadState* __tstate = wxPyBeginAllowThreads();
12722 result = (wxTraceMask)wxLog::GetTraceMask();
12723 wxPyEndAllowThreads(__tstate);
12724 if (PyErr_Occurred()) SWIG_fail;
12725 }
12726 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12727 return resultobj;
12728 fail:
12729 return NULL;
12730 }
12731
12732
12733 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12734 PyObject *resultobj = 0;
12735 wxChar *arg1 = (wxChar *) 0 ;
12736 bool result;
12737 void *argp1 = 0 ;
12738 int res1 = 0 ;
12739 PyObject * obj0 = 0 ;
12740 char * kwnames[] = {
12741 (char *) "mask", NULL
12742 };
12743
12744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12746 if (!SWIG_IsOK(res1)) {
12747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12748 }
12749 arg1 = reinterpret_cast< wxChar * >(argp1);
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 {
12757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12758 }
12759 return resultobj;
12760 fail:
12761 return NULL;
12762 }
12763
12764
12765 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12766 PyObject *resultobj = 0;
12767 wxLogLevel result;
12768
12769 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12770 {
12771 PyThreadState* __tstate = wxPyBeginAllowThreads();
12772 result = (wxLogLevel)wxLog::GetLogLevel();
12773 wxPyEndAllowThreads(__tstate);
12774 if (PyErr_Occurred()) SWIG_fail;
12775 }
12776 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12777 return resultobj;
12778 fail:
12779 return NULL;
12780 }
12781
12782
12783 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12784 PyObject *resultobj = 0;
12785 wxChar *result = 0 ;
12786
12787 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12788 {
12789 PyThreadState* __tstate = wxPyBeginAllowThreads();
12790 result = (wxChar *)wxLog::GetTimestamp();
12791 wxPyEndAllowThreads(__tstate);
12792 if (PyErr_Occurred()) SWIG_fail;
12793 }
12794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12795 return resultobj;
12796 fail:
12797 return NULL;
12798 }
12799
12800
12801 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12802 PyObject *resultobj = 0;
12803 wxString result;
12804
12805 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12806 {
12807 PyThreadState* __tstate = wxPyBeginAllowThreads();
12808 result = wxLog_TimeStamp();
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 {
12813 #if wxUSE_UNICODE
12814 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12815 #else
12816 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12817 #endif
12818 }
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12826 PyObject *resultobj = 0;
12827 wxLog *arg1 = (wxLog *) 0 ;
12828 void *argp1 = 0 ;
12829 int res1 = 0 ;
12830 PyObject *swig_obj[1] ;
12831
12832 if (!args) SWIG_fail;
12833 swig_obj[0] = args;
12834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12835 if (!SWIG_IsOK(res1)) {
12836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12837 }
12838 arg1 = reinterpret_cast< wxLog * >(argp1);
12839 {
12840 PyThreadState* __tstate = wxPyBeginAllowThreads();
12841 wxLog_Destroy(arg1);
12842 wxPyEndAllowThreads(__tstate);
12843 if (PyErr_Occurred()) SWIG_fail;
12844 }
12845 resultobj = SWIG_Py_Void();
12846 return resultobj;
12847 fail:
12848 return NULL;
12849 }
12850
12851
12852 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12853 PyObject *obj;
12854 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12855 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12856 return SWIG_Py_Void();
12857 }
12858
12859 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12860 return SWIG_Python_InitShadowInstance(args);
12861 }
12862
12863 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12864 PyObject *resultobj = 0;
12865 wxLogStderr *result = 0 ;
12866
12867 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12868 {
12869 PyThreadState* __tstate = wxPyBeginAllowThreads();
12870 result = (wxLogStderr *)new wxLogStderr();
12871 wxPyEndAllowThreads(__tstate);
12872 if (PyErr_Occurred()) SWIG_fail;
12873 }
12874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12875 return resultobj;
12876 fail:
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12882 PyObject *obj;
12883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12884 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12885 return SWIG_Py_Void();
12886 }
12887
12888 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12889 return SWIG_Python_InitShadowInstance(args);
12890 }
12891
12892 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12893 PyObject *resultobj = 0;
12894 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12895 wxLogTextCtrl *result = 0 ;
12896 void *argp1 = 0 ;
12897 int res1 = 0 ;
12898 PyObject * obj0 = 0 ;
12899 char * kwnames[] = {
12900 (char *) "pTextCtrl", NULL
12901 };
12902
12903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12905 if (!SWIG_IsOK(res1)) {
12906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12907 }
12908 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12909 {
12910 PyThreadState* __tstate = wxPyBeginAllowThreads();
12911 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12912 wxPyEndAllowThreads(__tstate);
12913 if (PyErr_Occurred()) SWIG_fail;
12914 }
12915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12916 return resultobj;
12917 fail:
12918 return NULL;
12919 }
12920
12921
12922 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12923 PyObject *obj;
12924 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12925 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12926 return SWIG_Py_Void();
12927 }
12928
12929 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12930 return SWIG_Python_InitShadowInstance(args);
12931 }
12932
12933 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12934 PyObject *resultobj = 0;
12935 wxLogGui *result = 0 ;
12936
12937 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12938 {
12939 PyThreadState* __tstate = wxPyBeginAllowThreads();
12940 result = (wxLogGui *)new wxLogGui();
12941 wxPyEndAllowThreads(__tstate);
12942 if (PyErr_Occurred()) SWIG_fail;
12943 }
12944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12945 return resultobj;
12946 fail:
12947 return NULL;
12948 }
12949
12950
12951 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12952 PyObject *obj;
12953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12954 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12955 return SWIG_Py_Void();
12956 }
12957
12958 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12959 return SWIG_Python_InitShadowInstance(args);
12960 }
12961
12962 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12963 PyObject *resultobj = 0;
12964 wxFrame *arg1 = (wxFrame *) 0 ;
12965 wxString *arg2 = 0 ;
12966 bool arg3 = (bool) true ;
12967 bool arg4 = (bool) true ;
12968 wxLogWindow *result = 0 ;
12969 void *argp1 = 0 ;
12970 int res1 = 0 ;
12971 bool temp2 = false ;
12972 bool val3 ;
12973 int ecode3 = 0 ;
12974 bool val4 ;
12975 int ecode4 = 0 ;
12976 PyObject * obj0 = 0 ;
12977 PyObject * obj1 = 0 ;
12978 PyObject * obj2 = 0 ;
12979 PyObject * obj3 = 0 ;
12980 char * kwnames[] = {
12981 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12982 };
12983
12984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12986 if (!SWIG_IsOK(res1)) {
12987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12988 }
12989 arg1 = reinterpret_cast< wxFrame * >(argp1);
12990 {
12991 arg2 = wxString_in_helper(obj1);
12992 if (arg2 == NULL) SWIG_fail;
12993 temp2 = true;
12994 }
12995 if (obj2) {
12996 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12997 if (!SWIG_IsOK(ecode3)) {
12998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
12999 }
13000 arg3 = static_cast< bool >(val3);
13001 }
13002 if (obj3) {
13003 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13004 if (!SWIG_IsOK(ecode4)) {
13005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13006 }
13007 arg4 = static_cast< bool >(val4);
13008 }
13009 {
13010 PyThreadState* __tstate = wxPyBeginAllowThreads();
13011 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13012 wxPyEndAllowThreads(__tstate);
13013 if (PyErr_Occurred()) SWIG_fail;
13014 }
13015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13016 {
13017 if (temp2)
13018 delete arg2;
13019 }
13020 return resultobj;
13021 fail:
13022 {
13023 if (temp2)
13024 delete arg2;
13025 }
13026 return NULL;
13027 }
13028
13029
13030 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13031 PyObject *resultobj = 0;
13032 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13033 bool arg2 = (bool) true ;
13034 void *argp1 = 0 ;
13035 int res1 = 0 ;
13036 bool val2 ;
13037 int ecode2 = 0 ;
13038 PyObject * obj0 = 0 ;
13039 PyObject * obj1 = 0 ;
13040 char * kwnames[] = {
13041 (char *) "self",(char *) "bShow", NULL
13042 };
13043
13044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13046 if (!SWIG_IsOK(res1)) {
13047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13048 }
13049 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13050 if (obj1) {
13051 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13052 if (!SWIG_IsOK(ecode2)) {
13053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13054 }
13055 arg2 = static_cast< bool >(val2);
13056 }
13057 {
13058 PyThreadState* __tstate = wxPyBeginAllowThreads();
13059 (arg1)->Show(arg2);
13060 wxPyEndAllowThreads(__tstate);
13061 if (PyErr_Occurred()) SWIG_fail;
13062 }
13063 resultobj = SWIG_Py_Void();
13064 return resultobj;
13065 fail:
13066 return NULL;
13067 }
13068
13069
13070 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13071 PyObject *resultobj = 0;
13072 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13073 wxFrame *result = 0 ;
13074 void *argp1 = 0 ;
13075 int res1 = 0 ;
13076 PyObject *swig_obj[1] ;
13077
13078 if (!args) SWIG_fail;
13079 swig_obj[0] = args;
13080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13081 if (!SWIG_IsOK(res1)) {
13082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13083 }
13084 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13085 {
13086 PyThreadState* __tstate = wxPyBeginAllowThreads();
13087 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13088 wxPyEndAllowThreads(__tstate);
13089 if (PyErr_Occurred()) SWIG_fail;
13090 }
13091 {
13092 resultobj = wxPyMake_wxObject(result, (bool)0);
13093 }
13094 return resultobj;
13095 fail:
13096 return NULL;
13097 }
13098
13099
13100 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13101 PyObject *resultobj = 0;
13102 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13103 wxLog *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_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13113 }
13114 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13129 PyObject *resultobj = 0;
13130 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13131 bool result;
13132 void *argp1 = 0 ;
13133 int res1 = 0 ;
13134 PyObject *swig_obj[1] ;
13135
13136 if (!args) SWIG_fail;
13137 swig_obj[0] = args;
13138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13139 if (!SWIG_IsOK(res1)) {
13140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13141 }
13142 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13143 {
13144 PyThreadState* __tstate = wxPyBeginAllowThreads();
13145 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13146 wxPyEndAllowThreads(__tstate);
13147 if (PyErr_Occurred()) SWIG_fail;
13148 }
13149 {
13150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13151 }
13152 return resultobj;
13153 fail:
13154 return NULL;
13155 }
13156
13157
13158 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13159 PyObject *resultobj = 0;
13160 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13161 bool arg2 ;
13162 void *argp1 = 0 ;
13163 int res1 = 0 ;
13164 bool val2 ;
13165 int ecode2 = 0 ;
13166 PyObject * obj0 = 0 ;
13167 PyObject * obj1 = 0 ;
13168 char * kwnames[] = {
13169 (char *) "self",(char *) "bDoPass", NULL
13170 };
13171
13172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13174 if (!SWIG_IsOK(res1)) {
13175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13176 }
13177 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13178 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13179 if (!SWIG_IsOK(ecode2)) {
13180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13181 }
13182 arg2 = static_cast< bool >(val2);
13183 {
13184 PyThreadState* __tstate = wxPyBeginAllowThreads();
13185 (arg1)->PassMessages(arg2);
13186 wxPyEndAllowThreads(__tstate);
13187 if (PyErr_Occurred()) SWIG_fail;
13188 }
13189 resultobj = SWIG_Py_Void();
13190 return resultobj;
13191 fail:
13192 return NULL;
13193 }
13194
13195
13196 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13197 PyObject *obj;
13198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13199 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13200 return SWIG_Py_Void();
13201 }
13202
13203 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13204 return SWIG_Python_InitShadowInstance(args);
13205 }
13206
13207 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13208 PyObject *resultobj = 0;
13209 wxLog *arg1 = (wxLog *) 0 ;
13210 wxLogChain *result = 0 ;
13211 void *argp1 = 0 ;
13212 int res1 = 0 ;
13213 PyObject * obj0 = 0 ;
13214 char * kwnames[] = {
13215 (char *) "logger", NULL
13216 };
13217
13218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13220 if (!SWIG_IsOK(res1)) {
13221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13222 }
13223 arg1 = reinterpret_cast< wxLog * >(argp1);
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 result = (wxLogChain *)new wxLogChain(arg1);
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13231 return resultobj;
13232 fail:
13233 return NULL;
13234 }
13235
13236
13237 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13238 PyObject *resultobj = 0;
13239 wxLogChain *arg1 = (wxLogChain *) 0 ;
13240 wxLog *arg2 = (wxLog *) 0 ;
13241 void *argp1 = 0 ;
13242 int res1 = 0 ;
13243 void *argp2 = 0 ;
13244 int res2 = 0 ;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 char * kwnames[] = {
13248 (char *) "self",(char *) "logger", NULL
13249 };
13250
13251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13253 if (!SWIG_IsOK(res1)) {
13254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13255 }
13256 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13258 if (!SWIG_IsOK(res2)) {
13259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13260 }
13261 arg2 = reinterpret_cast< wxLog * >(argp2);
13262 {
13263 PyThreadState* __tstate = wxPyBeginAllowThreads();
13264 (arg1)->SetLog(arg2);
13265 wxPyEndAllowThreads(__tstate);
13266 if (PyErr_Occurred()) SWIG_fail;
13267 }
13268 resultobj = SWIG_Py_Void();
13269 return resultobj;
13270 fail:
13271 return NULL;
13272 }
13273
13274
13275 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13276 PyObject *resultobj = 0;
13277 wxLogChain *arg1 = (wxLogChain *) 0 ;
13278 bool arg2 ;
13279 void *argp1 = 0 ;
13280 int res1 = 0 ;
13281 bool val2 ;
13282 int ecode2 = 0 ;
13283 PyObject * obj0 = 0 ;
13284 PyObject * obj1 = 0 ;
13285 char * kwnames[] = {
13286 (char *) "self",(char *) "bDoPass", NULL
13287 };
13288
13289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13291 if (!SWIG_IsOK(res1)) {
13292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13293 }
13294 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13295 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13296 if (!SWIG_IsOK(ecode2)) {
13297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13298 }
13299 arg2 = static_cast< bool >(val2);
13300 {
13301 PyThreadState* __tstate = wxPyBeginAllowThreads();
13302 (arg1)->PassMessages(arg2);
13303 wxPyEndAllowThreads(__tstate);
13304 if (PyErr_Occurred()) SWIG_fail;
13305 }
13306 resultobj = SWIG_Py_Void();
13307 return resultobj;
13308 fail:
13309 return NULL;
13310 }
13311
13312
13313 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13314 PyObject *resultobj = 0;
13315 wxLogChain *arg1 = (wxLogChain *) 0 ;
13316 bool result;
13317 void *argp1 = 0 ;
13318 int res1 = 0 ;
13319 PyObject *swig_obj[1] ;
13320
13321 if (!args) SWIG_fail;
13322 swig_obj[0] = args;
13323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13324 if (!SWIG_IsOK(res1)) {
13325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13326 }
13327 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13328 {
13329 PyThreadState* __tstate = wxPyBeginAllowThreads();
13330 result = (bool)(arg1)->IsPassingMessages();
13331 wxPyEndAllowThreads(__tstate);
13332 if (PyErr_Occurred()) SWIG_fail;
13333 }
13334 {
13335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13336 }
13337 return resultobj;
13338 fail:
13339 return NULL;
13340 }
13341
13342
13343 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13344 PyObject *resultobj = 0;
13345 wxLogChain *arg1 = (wxLogChain *) 0 ;
13346 wxLog *result = 0 ;
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_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13356 }
13357 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 result = (wxLog *)(arg1)->GetOldLog();
13361 wxPyEndAllowThreads(__tstate);
13362 if (PyErr_Occurred()) SWIG_fail;
13363 }
13364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13365 return resultobj;
13366 fail:
13367 return NULL;
13368 }
13369
13370
13371 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13372 PyObject *obj;
13373 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13374 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13375 return SWIG_Py_Void();
13376 }
13377
13378 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13379 return SWIG_Python_InitShadowInstance(args);
13380 }
13381
13382 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13383 PyObject *resultobj = 0;
13384 wxLogBuffer *result = 0 ;
13385
13386 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13387 {
13388 PyThreadState* __tstate = wxPyBeginAllowThreads();
13389 result = (wxLogBuffer *)new wxLogBuffer();
13390 wxPyEndAllowThreads(__tstate);
13391 if (PyErr_Occurred()) SWIG_fail;
13392 }
13393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13394 return resultobj;
13395 fail:
13396 return NULL;
13397 }
13398
13399
13400 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13401 PyObject *resultobj = 0;
13402 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13403 wxString *result = 0 ;
13404 void *argp1 = 0 ;
13405 int res1 = 0 ;
13406 PyObject *swig_obj[1] ;
13407
13408 if (!args) SWIG_fail;
13409 swig_obj[0] = args;
13410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13411 if (!SWIG_IsOK(res1)) {
13412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13413 }
13414 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13415 {
13416 PyThreadState* __tstate = wxPyBeginAllowThreads();
13417 {
13418 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13419 result = (wxString *) &_result_ref;
13420 }
13421 wxPyEndAllowThreads(__tstate);
13422 if (PyErr_Occurred()) SWIG_fail;
13423 }
13424 {
13425 #if wxUSE_UNICODE
13426 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13427 #else
13428 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13429 #endif
13430 }
13431 return resultobj;
13432 fail:
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13438 PyObject *obj;
13439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13440 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13441 return SWIG_Py_Void();
13442 }
13443
13444 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13445 return SWIG_Python_InitShadowInstance(args);
13446 }
13447
13448 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13449 PyObject *resultobj = 0;
13450 unsigned long result;
13451
13452 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 result = (unsigned long)wxSysErrorCode();
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13460 return resultobj;
13461 fail:
13462 return NULL;
13463 }
13464
13465
13466 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj = 0;
13468 unsigned long arg1 = (unsigned long) 0 ;
13469 wxString result;
13470 unsigned long val1 ;
13471 int ecode1 = 0 ;
13472 PyObject * obj0 = 0 ;
13473 char * kwnames[] = {
13474 (char *) "nErrCode", NULL
13475 };
13476
13477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13478 if (obj0) {
13479 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13480 if (!SWIG_IsOK(ecode1)) {
13481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13482 }
13483 arg1 = static_cast< unsigned long >(val1);
13484 }
13485 {
13486 PyThreadState* __tstate = wxPyBeginAllowThreads();
13487 result = wxSysErrorMsg(arg1);
13488 wxPyEndAllowThreads(__tstate);
13489 if (PyErr_Occurred()) SWIG_fail;
13490 }
13491 {
13492 #if wxUSE_UNICODE
13493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13494 #else
13495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13496 #endif
13497 }
13498 return resultobj;
13499 fail:
13500 return NULL;
13501 }
13502
13503
13504 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13505 PyObject *resultobj = 0;
13506 wxString *arg1 = 0 ;
13507 bool temp1 = false ;
13508 PyObject * obj0 = 0 ;
13509 char * kwnames[] = {
13510 (char *) "msg", NULL
13511 };
13512
13513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13514 {
13515 arg1 = wxString_in_helper(obj0);
13516 if (arg1 == NULL) SWIG_fail;
13517 temp1 = true;
13518 }
13519 {
13520 PyThreadState* __tstate = wxPyBeginAllowThreads();
13521 wxPyLogFatalError((wxString const &)*arg1);
13522 wxPyEndAllowThreads(__tstate);
13523 if (PyErr_Occurred()) SWIG_fail;
13524 }
13525 resultobj = SWIG_Py_Void();
13526 {
13527 if (temp1)
13528 delete arg1;
13529 }
13530 return resultobj;
13531 fail:
13532 {
13533 if (temp1)
13534 delete arg1;
13535 }
13536 return NULL;
13537 }
13538
13539
13540 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13541 PyObject *resultobj = 0;
13542 wxString *arg1 = 0 ;
13543 bool temp1 = false ;
13544 PyObject * obj0 = 0 ;
13545 char * kwnames[] = {
13546 (char *) "msg", NULL
13547 };
13548
13549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13550 {
13551 arg1 = wxString_in_helper(obj0);
13552 if (arg1 == NULL) SWIG_fail;
13553 temp1 = true;
13554 }
13555 {
13556 PyThreadState* __tstate = wxPyBeginAllowThreads();
13557 wxPyLogError((wxString const &)*arg1);
13558 wxPyEndAllowThreads(__tstate);
13559 if (PyErr_Occurred()) SWIG_fail;
13560 }
13561 resultobj = SWIG_Py_Void();
13562 {
13563 if (temp1)
13564 delete arg1;
13565 }
13566 return resultobj;
13567 fail:
13568 {
13569 if (temp1)
13570 delete arg1;
13571 }
13572 return NULL;
13573 }
13574
13575
13576 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13577 PyObject *resultobj = 0;
13578 wxString *arg1 = 0 ;
13579 bool temp1 = false ;
13580 PyObject * obj0 = 0 ;
13581 char * kwnames[] = {
13582 (char *) "msg", NULL
13583 };
13584
13585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13586 {
13587 arg1 = wxString_in_helper(obj0);
13588 if (arg1 == NULL) SWIG_fail;
13589 temp1 = true;
13590 }
13591 {
13592 PyThreadState* __tstate = wxPyBeginAllowThreads();
13593 wxPyLogWarning((wxString const &)*arg1);
13594 wxPyEndAllowThreads(__tstate);
13595 if (PyErr_Occurred()) SWIG_fail;
13596 }
13597 resultobj = SWIG_Py_Void();
13598 {
13599 if (temp1)
13600 delete arg1;
13601 }
13602 return resultobj;
13603 fail:
13604 {
13605 if (temp1)
13606 delete arg1;
13607 }
13608 return NULL;
13609 }
13610
13611
13612 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13613 PyObject *resultobj = 0;
13614 wxString *arg1 = 0 ;
13615 bool temp1 = false ;
13616 PyObject * obj0 = 0 ;
13617 char * kwnames[] = {
13618 (char *) "msg", NULL
13619 };
13620
13621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13622 {
13623 arg1 = wxString_in_helper(obj0);
13624 if (arg1 == NULL) SWIG_fail;
13625 temp1 = true;
13626 }
13627 {
13628 PyThreadState* __tstate = wxPyBeginAllowThreads();
13629 wxPyLogMessage((wxString const &)*arg1);
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 resultobj = SWIG_Py_Void();
13634 {
13635 if (temp1)
13636 delete arg1;
13637 }
13638 return resultobj;
13639 fail:
13640 {
13641 if (temp1)
13642 delete arg1;
13643 }
13644 return NULL;
13645 }
13646
13647
13648 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13649 PyObject *resultobj = 0;
13650 wxString *arg1 = 0 ;
13651 bool temp1 = false ;
13652 PyObject * obj0 = 0 ;
13653 char * kwnames[] = {
13654 (char *) "msg", NULL
13655 };
13656
13657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13658 {
13659 arg1 = wxString_in_helper(obj0);
13660 if (arg1 == NULL) SWIG_fail;
13661 temp1 = true;
13662 }
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 wxPyLogInfo((wxString const &)*arg1);
13666 wxPyEndAllowThreads(__tstate);
13667 if (PyErr_Occurred()) SWIG_fail;
13668 }
13669 resultobj = SWIG_Py_Void();
13670 {
13671 if (temp1)
13672 delete arg1;
13673 }
13674 return resultobj;
13675 fail:
13676 {
13677 if (temp1)
13678 delete arg1;
13679 }
13680 return NULL;
13681 }
13682
13683
13684 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj = 0;
13686 wxString *arg1 = 0 ;
13687 bool temp1 = false ;
13688 PyObject * obj0 = 0 ;
13689 char * kwnames[] = {
13690 (char *) "msg", NULL
13691 };
13692
13693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13694 {
13695 arg1 = wxString_in_helper(obj0);
13696 if (arg1 == NULL) SWIG_fail;
13697 temp1 = true;
13698 }
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 wxPyLogDebug((wxString const &)*arg1);
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 resultobj = SWIG_Py_Void();
13706 {
13707 if (temp1)
13708 delete arg1;
13709 }
13710 return resultobj;
13711 fail:
13712 {
13713 if (temp1)
13714 delete arg1;
13715 }
13716 return NULL;
13717 }
13718
13719
13720 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13721 PyObject *resultobj = 0;
13722 wxString *arg1 = 0 ;
13723 bool temp1 = false ;
13724 PyObject * obj0 = 0 ;
13725 char * kwnames[] = {
13726 (char *) "msg", NULL
13727 };
13728
13729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13730 {
13731 arg1 = wxString_in_helper(obj0);
13732 if (arg1 == NULL) SWIG_fail;
13733 temp1 = true;
13734 }
13735 {
13736 PyThreadState* __tstate = wxPyBeginAllowThreads();
13737 wxPyLogVerbose((wxString const &)*arg1);
13738 wxPyEndAllowThreads(__tstate);
13739 if (PyErr_Occurred()) SWIG_fail;
13740 }
13741 resultobj = SWIG_Py_Void();
13742 {
13743 if (temp1)
13744 delete arg1;
13745 }
13746 return resultobj;
13747 fail:
13748 {
13749 if (temp1)
13750 delete arg1;
13751 }
13752 return NULL;
13753 }
13754
13755
13756 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13757 PyObject *resultobj = 0;
13758 wxString *arg1 = 0 ;
13759 bool temp1 = false ;
13760 PyObject * obj0 = 0 ;
13761 char * kwnames[] = {
13762 (char *) "msg", NULL
13763 };
13764
13765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13766 {
13767 arg1 = wxString_in_helper(obj0);
13768 if (arg1 == NULL) SWIG_fail;
13769 temp1 = true;
13770 }
13771 {
13772 PyThreadState* __tstate = wxPyBeginAllowThreads();
13773 wxPyLogStatus((wxString const &)*arg1);
13774 wxPyEndAllowThreads(__tstate);
13775 if (PyErr_Occurred()) SWIG_fail;
13776 }
13777 resultobj = SWIG_Py_Void();
13778 {
13779 if (temp1)
13780 delete arg1;
13781 }
13782 return resultobj;
13783 fail:
13784 {
13785 if (temp1)
13786 delete arg1;
13787 }
13788 return NULL;
13789 }
13790
13791
13792 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13793 PyObject *resultobj = 0;
13794 wxFrame *arg1 = (wxFrame *) 0 ;
13795 wxString *arg2 = 0 ;
13796 void *argp1 = 0 ;
13797 int res1 = 0 ;
13798 bool temp2 = false ;
13799 PyObject * obj0 = 0 ;
13800 PyObject * obj1 = 0 ;
13801 char * kwnames[] = {
13802 (char *) "pFrame",(char *) "msg", NULL
13803 };
13804
13805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13807 if (!SWIG_IsOK(res1)) {
13808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13809 }
13810 arg1 = reinterpret_cast< wxFrame * >(argp1);
13811 {
13812 arg2 = wxString_in_helper(obj1);
13813 if (arg2 == NULL) SWIG_fail;
13814 temp2 = true;
13815 }
13816 {
13817 PyThreadState* __tstate = wxPyBeginAllowThreads();
13818 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13819 wxPyEndAllowThreads(__tstate);
13820 if (PyErr_Occurred()) SWIG_fail;
13821 }
13822 resultobj = SWIG_Py_Void();
13823 {
13824 if (temp2)
13825 delete arg2;
13826 }
13827 return resultobj;
13828 fail:
13829 {
13830 if (temp2)
13831 delete arg2;
13832 }
13833 return NULL;
13834 }
13835
13836
13837 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13838 PyObject *resultobj = 0;
13839 wxString *arg1 = 0 ;
13840 bool temp1 = false ;
13841 PyObject * obj0 = 0 ;
13842 char * kwnames[] = {
13843 (char *) "msg", NULL
13844 };
13845
13846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13847 {
13848 arg1 = wxString_in_helper(obj0);
13849 if (arg1 == NULL) SWIG_fail;
13850 temp1 = true;
13851 }
13852 {
13853 PyThreadState* __tstate = wxPyBeginAllowThreads();
13854 wxPyLogSysError((wxString const &)*arg1);
13855 wxPyEndAllowThreads(__tstate);
13856 if (PyErr_Occurred()) SWIG_fail;
13857 }
13858 resultobj = SWIG_Py_Void();
13859 {
13860 if (temp1)
13861 delete arg1;
13862 }
13863 return resultobj;
13864 fail:
13865 {
13866 if (temp1)
13867 delete arg1;
13868 }
13869 return NULL;
13870 }
13871
13872
13873 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13874 PyObject *resultobj = 0;
13875 unsigned long arg1 ;
13876 wxString *arg2 = 0 ;
13877 unsigned long val1 ;
13878 int ecode1 = 0 ;
13879 bool temp2 = false ;
13880 PyObject * obj0 = 0 ;
13881 PyObject * obj1 = 0 ;
13882 char * kwnames[] = {
13883 (char *) "level",(char *) "msg", NULL
13884 };
13885
13886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13887 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13888 if (!SWIG_IsOK(ecode1)) {
13889 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13890 }
13891 arg1 = static_cast< unsigned long >(val1);
13892 {
13893 arg2 = wxString_in_helper(obj1);
13894 if (arg2 == NULL) SWIG_fail;
13895 temp2 = true;
13896 }
13897 {
13898 PyThreadState* __tstate = wxPyBeginAllowThreads();
13899 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13900 wxPyEndAllowThreads(__tstate);
13901 if (PyErr_Occurred()) SWIG_fail;
13902 }
13903 resultobj = SWIG_Py_Void();
13904 {
13905 if (temp2)
13906 delete arg2;
13907 }
13908 return resultobj;
13909 fail:
13910 {
13911 if (temp2)
13912 delete arg2;
13913 }
13914 return NULL;
13915 }
13916
13917
13918 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13919 PyObject *resultobj = 0;
13920 unsigned long arg1 ;
13921 wxString *arg2 = 0 ;
13922 unsigned long val1 ;
13923 int ecode1 = 0 ;
13924 bool temp2 = false ;
13925
13926 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13927 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13928 if (!SWIG_IsOK(ecode1)) {
13929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13930 }
13931 arg1 = static_cast< unsigned long >(val1);
13932 {
13933 arg2 = wxString_in_helper(swig_obj[1]);
13934 if (arg2 == NULL) SWIG_fail;
13935 temp2 = true;
13936 }
13937 {
13938 PyThreadState* __tstate = wxPyBeginAllowThreads();
13939 wxPyLogTrace(arg1,(wxString const &)*arg2);
13940 wxPyEndAllowThreads(__tstate);
13941 if (PyErr_Occurred()) SWIG_fail;
13942 }
13943 resultobj = SWIG_Py_Void();
13944 {
13945 if (temp2)
13946 delete arg2;
13947 }
13948 return resultobj;
13949 fail:
13950 {
13951 if (temp2)
13952 delete arg2;
13953 }
13954 return NULL;
13955 }
13956
13957
13958 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13959 PyObject *resultobj = 0;
13960 wxString *arg1 = 0 ;
13961 wxString *arg2 = 0 ;
13962 bool temp1 = false ;
13963 bool temp2 = false ;
13964
13965 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13966 {
13967 arg1 = wxString_in_helper(swig_obj[0]);
13968 if (arg1 == NULL) SWIG_fail;
13969 temp1 = true;
13970 }
13971 {
13972 arg2 = wxString_in_helper(swig_obj[1]);
13973 if (arg2 == NULL) SWIG_fail;
13974 temp2 = true;
13975 }
13976 {
13977 PyThreadState* __tstate = wxPyBeginAllowThreads();
13978 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13979 wxPyEndAllowThreads(__tstate);
13980 if (PyErr_Occurred()) SWIG_fail;
13981 }
13982 resultobj = SWIG_Py_Void();
13983 {
13984 if (temp1)
13985 delete arg1;
13986 }
13987 {
13988 if (temp2)
13989 delete arg2;
13990 }
13991 return resultobj;
13992 fail:
13993 {
13994 if (temp1)
13995 delete arg1;
13996 }
13997 {
13998 if (temp2)
13999 delete arg2;
14000 }
14001 return NULL;
14002 }
14003
14004
14005 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14006 int argc;
14007 PyObject *argv[3];
14008
14009 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14010 --argc;
14011 if (argc == 2) {
14012 int _v = 0;
14013 {
14014 {
14015 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14016 }
14017 }
14018 if (!_v) goto check_1;
14019 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14020 }
14021 check_1:
14022
14023 if (argc == 2) {
14024 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14025 }
14026
14027 fail:
14028 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14029 return NULL;
14030 }
14031
14032
14033 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14034 PyObject *resultobj = 0;
14035 wxString *arg1 = 0 ;
14036 wxString *arg2 = 0 ;
14037 bool temp1 = false ;
14038 bool temp2 = false ;
14039 PyObject * obj0 = 0 ;
14040 PyObject * obj1 = 0 ;
14041 char * kwnames[] = {
14042 (char *) "title",(char *) "text", NULL
14043 };
14044
14045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14046 {
14047 arg1 = wxString_in_helper(obj0);
14048 if (arg1 == NULL) SWIG_fail;
14049 temp1 = true;
14050 }
14051 {
14052 arg2 = wxString_in_helper(obj1);
14053 if (arg2 == NULL) SWIG_fail;
14054 temp2 = true;
14055 }
14056 {
14057 PyThreadState* __tstate = wxPyBeginAllowThreads();
14058 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14059 wxPyEndAllowThreads(__tstate);
14060 if (PyErr_Occurred()) SWIG_fail;
14061 }
14062 resultobj = SWIG_Py_Void();
14063 {
14064 if (temp1)
14065 delete arg1;
14066 }
14067 {
14068 if (temp2)
14069 delete arg2;
14070 }
14071 return resultobj;
14072 fail:
14073 {
14074 if (temp1)
14075 delete arg1;
14076 }
14077 {
14078 if (temp2)
14079 delete arg2;
14080 }
14081 return NULL;
14082 }
14083
14084
14085 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14086 PyObject *resultobj = 0;
14087 wxLogNull *result = 0 ;
14088
14089 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 result = (wxLogNull *)new wxLogNull();
14093 wxPyEndAllowThreads(__tstate);
14094 if (PyErr_Occurred()) SWIG_fail;
14095 }
14096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14097 return resultobj;
14098 fail:
14099 return NULL;
14100 }
14101
14102
14103 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14104 PyObject *resultobj = 0;
14105 wxLogNull *arg1 = (wxLogNull *) 0 ;
14106 void *argp1 = 0 ;
14107 int res1 = 0 ;
14108 PyObject *swig_obj[1] ;
14109
14110 if (!args) SWIG_fail;
14111 swig_obj[0] = args;
14112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14113 if (!SWIG_IsOK(res1)) {
14114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14115 }
14116 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14117 {
14118 PyThreadState* __tstate = wxPyBeginAllowThreads();
14119 delete arg1;
14120
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 resultobj = SWIG_Py_Void();
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14132 PyObject *obj;
14133 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14134 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14135 return SWIG_Py_Void();
14136 }
14137
14138 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14139 return SWIG_Python_InitShadowInstance(args);
14140 }
14141
14142 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14143 PyObject *resultobj = 0;
14144 wxPyLog *result = 0 ;
14145
14146 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14147 {
14148 PyThreadState* __tstate = wxPyBeginAllowThreads();
14149 result = (wxPyLog *)new wxPyLog();
14150 wxPyEndAllowThreads(__tstate);
14151 if (PyErr_Occurred()) SWIG_fail;
14152 }
14153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14154 return resultobj;
14155 fail:
14156 return NULL;
14157 }
14158
14159
14160 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14161 PyObject *resultobj = 0;
14162 wxPyLog *arg1 = (wxPyLog *) 0 ;
14163 PyObject *arg2 = (PyObject *) 0 ;
14164 PyObject *arg3 = (PyObject *) 0 ;
14165 void *argp1 = 0 ;
14166 int res1 = 0 ;
14167 PyObject * obj0 = 0 ;
14168 PyObject * obj1 = 0 ;
14169 PyObject * obj2 = 0 ;
14170 char * kwnames[] = {
14171 (char *) "self",(char *) "self",(char *) "_class", NULL
14172 };
14173
14174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14176 if (!SWIG_IsOK(res1)) {
14177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14178 }
14179 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14180 arg2 = obj1;
14181 arg3 = obj2;
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 (arg1)->_setCallbackInfo(arg2,arg3);
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 resultobj = SWIG_Py_Void();
14189 return resultobj;
14190 fail:
14191 return NULL;
14192 }
14193
14194
14195 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14196 PyObject *obj;
14197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14198 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14199 return SWIG_Py_Void();
14200 }
14201
14202 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14203 return SWIG_Python_InitShadowInstance(args);
14204 }
14205
14206 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14207 PyObject *resultobj = 0;
14208 int arg1 ;
14209 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14210 int arg3 = (int) wxKILL_NOCHILDREN ;
14211 wxKillError result;
14212 int val1 ;
14213 int ecode1 = 0 ;
14214 int val2 ;
14215 int ecode2 = 0 ;
14216 int val3 ;
14217 int ecode3 = 0 ;
14218 PyObject * obj0 = 0 ;
14219 PyObject * obj1 = 0 ;
14220 PyObject * obj2 = 0 ;
14221 char * kwnames[] = {
14222 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14223 };
14224
14225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14226 ecode1 = SWIG_AsVal_int(obj0, &val1);
14227 if (!SWIG_IsOK(ecode1)) {
14228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14229 }
14230 arg1 = static_cast< int >(val1);
14231 if (obj1) {
14232 ecode2 = SWIG_AsVal_int(obj1, &val2);
14233 if (!SWIG_IsOK(ecode2)) {
14234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14235 }
14236 arg2 = static_cast< wxSignal >(val2);
14237 }
14238 if (obj2) {
14239 ecode3 = SWIG_AsVal_int(obj2, &val3);
14240 if (!SWIG_IsOK(ecode3)) {
14241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14242 }
14243 arg3 = static_cast< int >(val3);
14244 }
14245 {
14246 PyThreadState* __tstate = wxPyBeginAllowThreads();
14247 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14248 wxPyEndAllowThreads(__tstate);
14249 if (PyErr_Occurred()) SWIG_fail;
14250 }
14251 resultobj = SWIG_From_int(static_cast< int >(result));
14252 return resultobj;
14253 fail:
14254 return NULL;
14255 }
14256
14257
14258 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14259 PyObject *resultobj = 0;
14260 int arg1 ;
14261 bool result;
14262 int val1 ;
14263 int ecode1 = 0 ;
14264 PyObject * obj0 = 0 ;
14265 char * kwnames[] = {
14266 (char *) "pid", NULL
14267 };
14268
14269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14270 ecode1 = SWIG_AsVal_int(obj0, &val1);
14271 if (!SWIG_IsOK(ecode1)) {
14272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14273 }
14274 arg1 = static_cast< int >(val1);
14275 {
14276 PyThreadState* __tstate = wxPyBeginAllowThreads();
14277 result = (bool)wxPyProcess::Exists(arg1);
14278 wxPyEndAllowThreads(__tstate);
14279 if (PyErr_Occurred()) SWIG_fail;
14280 }
14281 {
14282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14283 }
14284 return resultobj;
14285 fail:
14286 return NULL;
14287 }
14288
14289
14290 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14291 PyObject *resultobj = 0;
14292 wxString *arg1 = 0 ;
14293 int arg2 = (int) wxEXEC_ASYNC ;
14294 wxPyProcess *result = 0 ;
14295 bool temp1 = false ;
14296 int val2 ;
14297 int ecode2 = 0 ;
14298 PyObject * obj0 = 0 ;
14299 PyObject * obj1 = 0 ;
14300 char * kwnames[] = {
14301 (char *) "cmd",(char *) "flags", NULL
14302 };
14303
14304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14305 {
14306 arg1 = wxString_in_helper(obj0);
14307 if (arg1 == NULL) SWIG_fail;
14308 temp1 = true;
14309 }
14310 if (obj1) {
14311 ecode2 = SWIG_AsVal_int(obj1, &val2);
14312 if (!SWIG_IsOK(ecode2)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14314 }
14315 arg2 = static_cast< int >(val2);
14316 }
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14324 {
14325 if (temp1)
14326 delete arg1;
14327 }
14328 return resultobj;
14329 fail:
14330 {
14331 if (temp1)
14332 delete arg1;
14333 }
14334 return NULL;
14335 }
14336
14337
14338 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14339 PyObject *resultobj = 0;
14340 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14341 int arg2 = (int) -1 ;
14342 wxPyProcess *result = 0 ;
14343 void *argp1 = 0 ;
14344 int res1 = 0 ;
14345 int val2 ;
14346 int ecode2 = 0 ;
14347 PyObject * obj0 = 0 ;
14348 PyObject * obj1 = 0 ;
14349 char * kwnames[] = {
14350 (char *) "parent",(char *) "id", NULL
14351 };
14352
14353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14354 if (obj0) {
14355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14356 if (!SWIG_IsOK(res1)) {
14357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14358 }
14359 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14360 }
14361 if (obj1) {
14362 ecode2 = SWIG_AsVal_int(obj1, &val2);
14363 if (!SWIG_IsOK(ecode2)) {
14364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14365 }
14366 arg2 = static_cast< int >(val2);
14367 }
14368 {
14369 PyThreadState* __tstate = wxPyBeginAllowThreads();
14370 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14371 wxPyEndAllowThreads(__tstate);
14372 if (PyErr_Occurred()) SWIG_fail;
14373 }
14374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14375 return resultobj;
14376 fail:
14377 return NULL;
14378 }
14379
14380
14381 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14382 PyObject *resultobj = 0;
14383 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14384 void *argp1 = 0 ;
14385 int res1 = 0 ;
14386 PyObject *swig_obj[1] ;
14387
14388 if (!args) SWIG_fail;
14389 swig_obj[0] = args;
14390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14391 if (!SWIG_IsOK(res1)) {
14392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14393 }
14394 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 delete arg1;
14398
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_Py_Void();
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14410 PyObject *resultobj = 0;
14411 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14412 PyObject *arg2 = (PyObject *) 0 ;
14413 PyObject *arg3 = (PyObject *) 0 ;
14414 void *argp1 = 0 ;
14415 int res1 = 0 ;
14416 PyObject * obj0 = 0 ;
14417 PyObject * obj1 = 0 ;
14418 PyObject * obj2 = 0 ;
14419 char * kwnames[] = {
14420 (char *) "self",(char *) "self",(char *) "_class", NULL
14421 };
14422
14423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14425 if (!SWIG_IsOK(res1)) {
14426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14427 }
14428 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14429 arg2 = obj1;
14430 arg3 = obj2;
14431 {
14432 PyThreadState* __tstate = wxPyBeginAllowThreads();
14433 (arg1)->_setCallbackInfo(arg2,arg3);
14434 wxPyEndAllowThreads(__tstate);
14435 if (PyErr_Occurred()) SWIG_fail;
14436 }
14437 resultobj = SWIG_Py_Void();
14438 return resultobj;
14439 fail:
14440 return NULL;
14441 }
14442
14443
14444 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14445 PyObject *resultobj = 0;
14446 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14447 long result;
14448 void *argp1 = 0 ;
14449 int res1 = 0 ;
14450 PyObject *swig_obj[1] ;
14451
14452 if (!args) SWIG_fail;
14453 swig_obj[0] = args;
14454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14455 if (!SWIG_IsOK(res1)) {
14456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14457 }
14458 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14459 {
14460 PyThreadState* __tstate = wxPyBeginAllowThreads();
14461 result = (long)((wxPyProcess const *)arg1)->GetPid();
14462 wxPyEndAllowThreads(__tstate);
14463 if (PyErr_Occurred()) SWIG_fail;
14464 }
14465 resultobj = SWIG_From_long(static_cast< long >(result));
14466 return resultobj;
14467 fail:
14468 return NULL;
14469 }
14470
14471
14472 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14473 PyObject *resultobj = 0;
14474 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14475 int arg2 ;
14476 int arg3 ;
14477 void *argp1 = 0 ;
14478 int res1 = 0 ;
14479 int val2 ;
14480 int ecode2 = 0 ;
14481 int val3 ;
14482 int ecode3 = 0 ;
14483 PyObject * obj0 = 0 ;
14484 PyObject * obj1 = 0 ;
14485 PyObject * obj2 = 0 ;
14486 char * kwnames[] = {
14487 (char *) "self",(char *) "pid",(char *) "status", NULL
14488 };
14489
14490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14492 if (!SWIG_IsOK(res1)) {
14493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14494 }
14495 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14496 ecode2 = SWIG_AsVal_int(obj1, &val2);
14497 if (!SWIG_IsOK(ecode2)) {
14498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14499 }
14500 arg2 = static_cast< int >(val2);
14501 ecode3 = SWIG_AsVal_int(obj2, &val3);
14502 if (!SWIG_IsOK(ecode3)) {
14503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14504 }
14505 arg3 = static_cast< int >(val3);
14506 {
14507 PyThreadState* __tstate = wxPyBeginAllowThreads();
14508 (arg1)->OnTerminate(arg2,arg3);
14509 wxPyEndAllowThreads(__tstate);
14510 if (PyErr_Occurred()) SWIG_fail;
14511 }
14512 resultobj = SWIG_Py_Void();
14513 return resultobj;
14514 fail:
14515 return NULL;
14516 }
14517
14518
14519 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14520 PyObject *resultobj = 0;
14521 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14522 void *argp1 = 0 ;
14523 int res1 = 0 ;
14524 PyObject *swig_obj[1] ;
14525
14526 if (!args) SWIG_fail;
14527 swig_obj[0] = args;
14528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14529 if (!SWIG_IsOK(res1)) {
14530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14531 }
14532 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14533 {
14534 PyThreadState* __tstate = wxPyBeginAllowThreads();
14535 (arg1)->Redirect();
14536 wxPyEndAllowThreads(__tstate);
14537 if (PyErr_Occurred()) SWIG_fail;
14538 }
14539 resultobj = SWIG_Py_Void();
14540 return resultobj;
14541 fail:
14542 return NULL;
14543 }
14544
14545
14546 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14547 PyObject *resultobj = 0;
14548 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14549 bool result;
14550 void *argp1 = 0 ;
14551 int res1 = 0 ;
14552 PyObject *swig_obj[1] ;
14553
14554 if (!args) SWIG_fail;
14555 swig_obj[0] = args;
14556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14557 if (!SWIG_IsOK(res1)) {
14558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14559 }
14560 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14561 {
14562 PyThreadState* __tstate = wxPyBeginAllowThreads();
14563 result = (bool)(arg1)->IsRedirected();
14564 wxPyEndAllowThreads(__tstate);
14565 if (PyErr_Occurred()) SWIG_fail;
14566 }
14567 {
14568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14569 }
14570 return resultobj;
14571 fail:
14572 return NULL;
14573 }
14574
14575
14576 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14577 PyObject *resultobj = 0;
14578 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14579 void *argp1 = 0 ;
14580 int res1 = 0 ;
14581 PyObject *swig_obj[1] ;
14582
14583 if (!args) SWIG_fail;
14584 swig_obj[0] = args;
14585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14586 if (!SWIG_IsOK(res1)) {
14587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14588 }
14589 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14590 {
14591 PyThreadState* __tstate = wxPyBeginAllowThreads();
14592 (arg1)->Detach();
14593 wxPyEndAllowThreads(__tstate);
14594 if (PyErr_Occurred()) SWIG_fail;
14595 }
14596 resultobj = SWIG_Py_Void();
14597 return resultobj;
14598 fail:
14599 return NULL;
14600 }
14601
14602
14603 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14604 PyObject *resultobj = 0;
14605 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14606 wxInputStream *result = 0 ;
14607 void *argp1 = 0 ;
14608 int res1 = 0 ;
14609 PyObject *swig_obj[1] ;
14610
14611 if (!args) SWIG_fail;
14612 swig_obj[0] = args;
14613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14614 if (!SWIG_IsOK(res1)) {
14615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14616 }
14617 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14618 {
14619 PyThreadState* __tstate = wxPyBeginAllowThreads();
14620 result = (wxInputStream *)(arg1)->GetInputStream();
14621 wxPyEndAllowThreads(__tstate);
14622 if (PyErr_Occurred()) SWIG_fail;
14623 }
14624 {
14625 wxPyInputStream * _ptr = NULL;
14626
14627 if (result) {
14628 _ptr = new wxPyInputStream(result);
14629 }
14630 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14631 }
14632 return resultobj;
14633 fail:
14634 return NULL;
14635 }
14636
14637
14638 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14639 PyObject *resultobj = 0;
14640 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14641 wxInputStream *result = 0 ;
14642 void *argp1 = 0 ;
14643 int res1 = 0 ;
14644 PyObject *swig_obj[1] ;
14645
14646 if (!args) SWIG_fail;
14647 swig_obj[0] = args;
14648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14649 if (!SWIG_IsOK(res1)) {
14650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14651 }
14652 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14653 {
14654 PyThreadState* __tstate = wxPyBeginAllowThreads();
14655 result = (wxInputStream *)(arg1)->GetErrorStream();
14656 wxPyEndAllowThreads(__tstate);
14657 if (PyErr_Occurred()) SWIG_fail;
14658 }
14659 {
14660 wxPyInputStream * _ptr = NULL;
14661
14662 if (result) {
14663 _ptr = new wxPyInputStream(result);
14664 }
14665 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14666 }
14667 return resultobj;
14668 fail:
14669 return NULL;
14670 }
14671
14672
14673 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14674 PyObject *resultobj = 0;
14675 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14676 wxOutputStream *result = 0 ;
14677 void *argp1 = 0 ;
14678 int res1 = 0 ;
14679 PyObject *swig_obj[1] ;
14680
14681 if (!args) SWIG_fail;
14682 swig_obj[0] = args;
14683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14684 if (!SWIG_IsOK(res1)) {
14685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14686 }
14687 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14688 {
14689 PyThreadState* __tstate = wxPyBeginAllowThreads();
14690 result = (wxOutputStream *)(arg1)->GetOutputStream();
14691 wxPyEndAllowThreads(__tstate);
14692 if (PyErr_Occurred()) SWIG_fail;
14693 }
14694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14695 return resultobj;
14696 fail:
14697 return NULL;
14698 }
14699
14700
14701 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14702 PyObject *resultobj = 0;
14703 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14704 void *argp1 = 0 ;
14705 int res1 = 0 ;
14706 PyObject *swig_obj[1] ;
14707
14708 if (!args) SWIG_fail;
14709 swig_obj[0] = args;
14710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14711 if (!SWIG_IsOK(res1)) {
14712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14713 }
14714 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 (arg1)->CloseOutput();
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 resultobj = SWIG_Py_Void();
14722 return resultobj;
14723 fail:
14724 return NULL;
14725 }
14726
14727
14728 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14729 PyObject *resultobj = 0;
14730 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14731 bool result;
14732 void *argp1 = 0 ;
14733 int res1 = 0 ;
14734 PyObject *swig_obj[1] ;
14735
14736 if (!args) SWIG_fail;
14737 swig_obj[0] = args;
14738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14739 if (!SWIG_IsOK(res1)) {
14740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14741 }
14742 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14743 {
14744 PyThreadState* __tstate = wxPyBeginAllowThreads();
14745 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14746 wxPyEndAllowThreads(__tstate);
14747 if (PyErr_Occurred()) SWIG_fail;
14748 }
14749 {
14750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14751 }
14752 return resultobj;
14753 fail:
14754 return NULL;
14755 }
14756
14757
14758 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(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_IsInputAvailable" "', 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)->IsInputAvailable();
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_IsErrorAvailable(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_IsErrorAvailable" "', 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)->IsErrorAvailable();
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 *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14819 PyObject *obj;
14820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14821 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14822 return SWIG_Py_Void();
14823 }
14824
14825 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14826 return SWIG_Python_InitShadowInstance(args);
14827 }
14828
14829 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14830 PyObject *resultobj = 0;
14831 int arg1 = (int) 0 ;
14832 int arg2 = (int) 0 ;
14833 int arg3 = (int) 0 ;
14834 wxProcessEvent *result = 0 ;
14835 int val1 ;
14836 int ecode1 = 0 ;
14837 int val2 ;
14838 int ecode2 = 0 ;
14839 int val3 ;
14840 int ecode3 = 0 ;
14841 PyObject * obj0 = 0 ;
14842 PyObject * obj1 = 0 ;
14843 PyObject * obj2 = 0 ;
14844 char * kwnames[] = {
14845 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14846 };
14847
14848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14849 if (obj0) {
14850 ecode1 = SWIG_AsVal_int(obj0, &val1);
14851 if (!SWIG_IsOK(ecode1)) {
14852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14853 }
14854 arg1 = static_cast< int >(val1);
14855 }
14856 if (obj1) {
14857 ecode2 = SWIG_AsVal_int(obj1, &val2);
14858 if (!SWIG_IsOK(ecode2)) {
14859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14860 }
14861 arg2 = static_cast< int >(val2);
14862 }
14863 if (obj2) {
14864 ecode3 = SWIG_AsVal_int(obj2, &val3);
14865 if (!SWIG_IsOK(ecode3)) {
14866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14867 }
14868 arg3 = static_cast< int >(val3);
14869 }
14870 {
14871 PyThreadState* __tstate = wxPyBeginAllowThreads();
14872 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14873 wxPyEndAllowThreads(__tstate);
14874 if (PyErr_Occurred()) SWIG_fail;
14875 }
14876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14877 return resultobj;
14878 fail:
14879 return NULL;
14880 }
14881
14882
14883 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14884 PyObject *resultobj = 0;
14885 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14886 int result;
14887 void *argp1 = 0 ;
14888 int res1 = 0 ;
14889 PyObject *swig_obj[1] ;
14890
14891 if (!args) SWIG_fail;
14892 swig_obj[0] = args;
14893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14894 if (!SWIG_IsOK(res1)) {
14895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14896 }
14897 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14898 {
14899 PyThreadState* __tstate = wxPyBeginAllowThreads();
14900 result = (int)(arg1)->GetPid();
14901 wxPyEndAllowThreads(__tstate);
14902 if (PyErr_Occurred()) SWIG_fail;
14903 }
14904 resultobj = SWIG_From_int(static_cast< int >(result));
14905 return resultobj;
14906 fail:
14907 return NULL;
14908 }
14909
14910
14911 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14912 PyObject *resultobj = 0;
14913 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14914 int result;
14915 void *argp1 = 0 ;
14916 int res1 = 0 ;
14917 PyObject *swig_obj[1] ;
14918
14919 if (!args) SWIG_fail;
14920 swig_obj[0] = args;
14921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14922 if (!SWIG_IsOK(res1)) {
14923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14924 }
14925 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14926 {
14927 PyThreadState* __tstate = wxPyBeginAllowThreads();
14928 result = (int)(arg1)->GetExitCode();
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 resultobj = SWIG_From_int(static_cast< int >(result));
14933 return resultobj;
14934 fail:
14935 return NULL;
14936 }
14937
14938
14939 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14940 PyObject *resultobj = 0;
14941 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14942 int arg2 ;
14943 void *argp1 = 0 ;
14944 int res1 = 0 ;
14945 int val2 ;
14946 int ecode2 = 0 ;
14947 PyObject *swig_obj[2] ;
14948
14949 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14951 if (!SWIG_IsOK(res1)) {
14952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14953 }
14954 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14955 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14956 if (!SWIG_IsOK(ecode2)) {
14957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14958 }
14959 arg2 = static_cast< int >(val2);
14960 if (arg1) (arg1)->m_pid = arg2;
14961
14962 resultobj = SWIG_Py_Void();
14963 return resultobj;
14964 fail:
14965 return NULL;
14966 }
14967
14968
14969 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14970 PyObject *resultobj = 0;
14971 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14972 int result;
14973 void *argp1 = 0 ;
14974 int res1 = 0 ;
14975 PyObject *swig_obj[1] ;
14976
14977 if (!args) SWIG_fail;
14978 swig_obj[0] = args;
14979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14980 if (!SWIG_IsOK(res1)) {
14981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14982 }
14983 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14984 result = (int) ((arg1)->m_pid);
14985 resultobj = SWIG_From_int(static_cast< int >(result));
14986 return resultobj;
14987 fail:
14988 return NULL;
14989 }
14990
14991
14992 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14993 PyObject *resultobj = 0;
14994 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14995 int arg2 ;
14996 void *argp1 = 0 ;
14997 int res1 = 0 ;
14998 int val2 ;
14999 int ecode2 = 0 ;
15000 PyObject *swig_obj[2] ;
15001
15002 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15004 if (!SWIG_IsOK(res1)) {
15005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15006 }
15007 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15008 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15009 if (!SWIG_IsOK(ecode2)) {
15010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15011 }
15012 arg2 = static_cast< int >(val2);
15013 if (arg1) (arg1)->m_exitcode = arg2;
15014
15015 resultobj = SWIG_Py_Void();
15016 return resultobj;
15017 fail:
15018 return NULL;
15019 }
15020
15021
15022 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15023 PyObject *resultobj = 0;
15024 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15025 int result;
15026 void *argp1 = 0 ;
15027 int res1 = 0 ;
15028 PyObject *swig_obj[1] ;
15029
15030 if (!args) SWIG_fail;
15031 swig_obj[0] = args;
15032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15033 if (!SWIG_IsOK(res1)) {
15034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15035 }
15036 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15037 result = (int) ((arg1)->m_exitcode);
15038 resultobj = SWIG_From_int(static_cast< int >(result));
15039 return resultobj;
15040 fail:
15041 return NULL;
15042 }
15043
15044
15045 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15046 PyObject *obj;
15047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15048 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15049 return SWIG_Py_Void();
15050 }
15051
15052 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15053 return SWIG_Python_InitShadowInstance(args);
15054 }
15055
15056 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15057 PyObject *resultobj = 0;
15058 wxString *arg1 = 0 ;
15059 int arg2 = (int) wxEXEC_ASYNC ;
15060 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15061 long result;
15062 bool temp1 = false ;
15063 int val2 ;
15064 int ecode2 = 0 ;
15065 void *argp3 = 0 ;
15066 int res3 = 0 ;
15067 PyObject * obj0 = 0 ;
15068 PyObject * obj1 = 0 ;
15069 PyObject * obj2 = 0 ;
15070 char * kwnames[] = {
15071 (char *) "command",(char *) "flags",(char *) "process", NULL
15072 };
15073
15074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15075 {
15076 arg1 = wxString_in_helper(obj0);
15077 if (arg1 == NULL) SWIG_fail;
15078 temp1 = true;
15079 }
15080 if (obj1) {
15081 ecode2 = SWIG_AsVal_int(obj1, &val2);
15082 if (!SWIG_IsOK(ecode2)) {
15083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15084 }
15085 arg2 = static_cast< int >(val2);
15086 }
15087 if (obj2) {
15088 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15089 if (!SWIG_IsOK(res3)) {
15090 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15091 }
15092 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15093 }
15094 {
15095 if (!wxPyCheckForApp()) SWIG_fail;
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15098 wxPyEndAllowThreads(__tstate);
15099 if (PyErr_Occurred()) SWIG_fail;
15100 }
15101 resultobj = SWIG_From_long(static_cast< long >(result));
15102 {
15103 if (temp1)
15104 delete arg1;
15105 }
15106 return resultobj;
15107 fail:
15108 {
15109 if (temp1)
15110 delete arg1;
15111 }
15112 return NULL;
15113 }
15114
15115
15116 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15117 PyObject *resultobj = 0;
15118 long arg1 ;
15119 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15120 wxKillError *arg3 = (wxKillError *) 0 ;
15121 int arg4 = (int) wxKILL_NOCHILDREN ;
15122 int result;
15123 long val1 ;
15124 int ecode1 = 0 ;
15125 int val2 ;
15126 int ecode2 = 0 ;
15127 wxKillError temp3 ;
15128 int val4 ;
15129 int ecode4 = 0 ;
15130 PyObject * obj0 = 0 ;
15131 PyObject * obj1 = 0 ;
15132 PyObject * obj2 = 0 ;
15133 char * kwnames[] = {
15134 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15135 };
15136
15137 {
15138 arg3 = &temp3;
15139 }
15140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15141 ecode1 = SWIG_AsVal_long(obj0, &val1);
15142 if (!SWIG_IsOK(ecode1)) {
15143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15144 }
15145 arg1 = static_cast< long >(val1);
15146 if (obj1) {
15147 ecode2 = SWIG_AsVal_int(obj1, &val2);
15148 if (!SWIG_IsOK(ecode2)) {
15149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15150 }
15151 arg2 = static_cast< wxSignal >(val2);
15152 }
15153 if (obj2) {
15154 ecode4 = SWIG_AsVal_int(obj2, &val4);
15155 if (!SWIG_IsOK(ecode4)) {
15156 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15157 }
15158 arg4 = static_cast< int >(val4);
15159 }
15160 {
15161 PyThreadState* __tstate = wxPyBeginAllowThreads();
15162 result = (int)wxKill(arg1,arg2,arg3,arg4);
15163 wxPyEndAllowThreads(__tstate);
15164 if (PyErr_Occurred()) SWIG_fail;
15165 }
15166 resultobj = SWIG_From_int(static_cast< int >(result));
15167 {
15168 PyObject* o;
15169 o = PyInt_FromLong((long) (*arg3));
15170
15171
15172
15173 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15174
15175 }
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15183 PyObject *resultobj = 0;
15184 int arg1 = (int) wxJOYSTICK1 ;
15185 wxJoystick *result = 0 ;
15186 int val1 ;
15187 int ecode1 = 0 ;
15188 PyObject * obj0 = 0 ;
15189 char * kwnames[] = {
15190 (char *) "joystick", NULL
15191 };
15192
15193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15194 if (obj0) {
15195 ecode1 = SWIG_AsVal_int(obj0, &val1);
15196 if (!SWIG_IsOK(ecode1)) {
15197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15198 }
15199 arg1 = static_cast< int >(val1);
15200 }
15201 {
15202 if (!wxPyCheckForApp()) SWIG_fail;
15203 PyThreadState* __tstate = wxPyBeginAllowThreads();
15204 result = (wxJoystick *)new wxJoystick(arg1);
15205 wxPyEndAllowThreads(__tstate);
15206 if (PyErr_Occurred()) SWIG_fail;
15207 }
15208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15209 return resultobj;
15210 fail:
15211 return NULL;
15212 }
15213
15214
15215 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15216 PyObject *resultobj = 0;
15217 wxJoystick *arg1 = (wxJoystick *) 0 ;
15218 void *argp1 = 0 ;
15219 int res1 = 0 ;
15220 PyObject *swig_obj[1] ;
15221
15222 if (!args) SWIG_fail;
15223 swig_obj[0] = args;
15224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15225 if (!SWIG_IsOK(res1)) {
15226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15227 }
15228 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15229 {
15230 PyThreadState* __tstate = wxPyBeginAllowThreads();
15231 delete arg1;
15232
15233 wxPyEndAllowThreads(__tstate);
15234 if (PyErr_Occurred()) SWIG_fail;
15235 }
15236 resultobj = SWIG_Py_Void();
15237 return resultobj;
15238 fail:
15239 return NULL;
15240 }
15241
15242
15243 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15244 PyObject *resultobj = 0;
15245 wxJoystick *arg1 = (wxJoystick *) 0 ;
15246 wxPoint result;
15247 void *argp1 = 0 ;
15248 int res1 = 0 ;
15249 PyObject *swig_obj[1] ;
15250
15251 if (!args) SWIG_fail;
15252 swig_obj[0] = args;
15253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15254 if (!SWIG_IsOK(res1)) {
15255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15256 }
15257 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15258 {
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 result = (arg1)->GetPosition();
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15265 return resultobj;
15266 fail:
15267 return NULL;
15268 }
15269
15270
15271 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272 PyObject *resultobj = 0;
15273 wxJoystick *arg1 = (wxJoystick *) 0 ;
15274 int result;
15275 void *argp1 = 0 ;
15276 int res1 = 0 ;
15277 PyObject *swig_obj[1] ;
15278
15279 if (!args) SWIG_fail;
15280 swig_obj[0] = args;
15281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15282 if (!SWIG_IsOK(res1)) {
15283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15284 }
15285 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15286 {
15287 PyThreadState* __tstate = wxPyBeginAllowThreads();
15288 result = (int)(arg1)->GetZPosition();
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = SWIG_From_int(static_cast< int >(result));
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15300 PyObject *resultobj = 0;
15301 wxJoystick *arg1 = (wxJoystick *) 0 ;
15302 int result;
15303 void *argp1 = 0 ;
15304 int res1 = 0 ;
15305 PyObject *swig_obj[1] ;
15306
15307 if (!args) SWIG_fail;
15308 swig_obj[0] = args;
15309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15310 if (!SWIG_IsOK(res1)) {
15311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15312 }
15313 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 result = (int)(arg1)->GetButtonState();
15317 wxPyEndAllowThreads(__tstate);
15318 if (PyErr_Occurred()) SWIG_fail;
15319 }
15320 resultobj = SWIG_From_int(static_cast< int >(result));
15321 return resultobj;
15322 fail:
15323 return NULL;
15324 }
15325
15326
15327 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15328 PyObject *resultobj = 0;
15329 wxJoystick *arg1 = (wxJoystick *) 0 ;
15330 int result;
15331 void *argp1 = 0 ;
15332 int res1 = 0 ;
15333 PyObject *swig_obj[1] ;
15334
15335 if (!args) SWIG_fail;
15336 swig_obj[0] = args;
15337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15338 if (!SWIG_IsOK(res1)) {
15339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15340 }
15341 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 result = (int)(arg1)->GetPOVPosition();
15345 wxPyEndAllowThreads(__tstate);
15346 if (PyErr_Occurred()) SWIG_fail;
15347 }
15348 resultobj = SWIG_From_int(static_cast< int >(result));
15349 return resultobj;
15350 fail:
15351 return NULL;
15352 }
15353
15354
15355 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15356 PyObject *resultobj = 0;
15357 wxJoystick *arg1 = (wxJoystick *) 0 ;
15358 int result;
15359 void *argp1 = 0 ;
15360 int res1 = 0 ;
15361 PyObject *swig_obj[1] ;
15362
15363 if (!args) SWIG_fail;
15364 swig_obj[0] = args;
15365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15366 if (!SWIG_IsOK(res1)) {
15367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15368 }
15369 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 result = (int)(arg1)->GetPOVCTSPosition();
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 resultobj = SWIG_From_int(static_cast< int >(result));
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxJoystick *arg1 = (wxJoystick *) 0 ;
15386 int result;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15396 }
15397 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 result = (int)(arg1)->GetRudderPosition();
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 resultobj = SWIG_From_int(static_cast< int >(result));
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15412 PyObject *resultobj = 0;
15413 wxJoystick *arg1 = (wxJoystick *) 0 ;
15414 int result;
15415 void *argp1 = 0 ;
15416 int res1 = 0 ;
15417 PyObject *swig_obj[1] ;
15418
15419 if (!args) SWIG_fail;
15420 swig_obj[0] = args;
15421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15422 if (!SWIG_IsOK(res1)) {
15423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15424 }
15425 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15426 {
15427 PyThreadState* __tstate = wxPyBeginAllowThreads();
15428 result = (int)(arg1)->GetUPosition();
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 resultobj = SWIG_From_int(static_cast< int >(result));
15433 return resultobj;
15434 fail:
15435 return NULL;
15436 }
15437
15438
15439 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15440 PyObject *resultobj = 0;
15441 wxJoystick *arg1 = (wxJoystick *) 0 ;
15442 int result;
15443 void *argp1 = 0 ;
15444 int res1 = 0 ;
15445 PyObject *swig_obj[1] ;
15446
15447 if (!args) SWIG_fail;
15448 swig_obj[0] = args;
15449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15450 if (!SWIG_IsOK(res1)) {
15451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15452 }
15453 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15454 {
15455 PyThreadState* __tstate = wxPyBeginAllowThreads();
15456 result = (int)(arg1)->GetVPosition();
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 resultobj = SWIG_From_int(static_cast< int >(result));
15461 return resultobj;
15462 fail:
15463 return NULL;
15464 }
15465
15466
15467 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15468 PyObject *resultobj = 0;
15469 wxJoystick *arg1 = (wxJoystick *) 0 ;
15470 int result;
15471 void *argp1 = 0 ;
15472 int res1 = 0 ;
15473 PyObject *swig_obj[1] ;
15474
15475 if (!args) SWIG_fail;
15476 swig_obj[0] = args;
15477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15478 if (!SWIG_IsOK(res1)) {
15479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15480 }
15481 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (int)(arg1)->GetMovementThreshold();
15485 wxPyEndAllowThreads(__tstate);
15486 if (PyErr_Occurred()) SWIG_fail;
15487 }
15488 resultobj = SWIG_From_int(static_cast< int >(result));
15489 return resultobj;
15490 fail:
15491 return NULL;
15492 }
15493
15494
15495 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15496 PyObject *resultobj = 0;
15497 wxJoystick *arg1 = (wxJoystick *) 0 ;
15498 int arg2 ;
15499 void *argp1 = 0 ;
15500 int res1 = 0 ;
15501 int val2 ;
15502 int ecode2 = 0 ;
15503 PyObject * obj0 = 0 ;
15504 PyObject * obj1 = 0 ;
15505 char * kwnames[] = {
15506 (char *) "self",(char *) "threshold", NULL
15507 };
15508
15509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15511 if (!SWIG_IsOK(res1)) {
15512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15513 }
15514 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15515 ecode2 = SWIG_AsVal_int(obj1, &val2);
15516 if (!SWIG_IsOK(ecode2)) {
15517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15518 }
15519 arg2 = static_cast< int >(val2);
15520 {
15521 PyThreadState* __tstate = wxPyBeginAllowThreads();
15522 (arg1)->SetMovementThreshold(arg2);
15523 wxPyEndAllowThreads(__tstate);
15524 if (PyErr_Occurred()) SWIG_fail;
15525 }
15526 resultobj = SWIG_Py_Void();
15527 return resultobj;
15528 fail:
15529 return NULL;
15530 }
15531
15532
15533 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15534 PyObject *resultobj = 0;
15535 wxJoystick *arg1 = (wxJoystick *) 0 ;
15536 bool result;
15537 void *argp1 = 0 ;
15538 int res1 = 0 ;
15539 PyObject *swig_obj[1] ;
15540
15541 if (!args) SWIG_fail;
15542 swig_obj[0] = args;
15543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15544 if (!SWIG_IsOK(res1)) {
15545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15546 }
15547 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15548 {
15549 PyThreadState* __tstate = wxPyBeginAllowThreads();
15550 result = (bool)(arg1)->IsOk();
15551 wxPyEndAllowThreads(__tstate);
15552 if (PyErr_Occurred()) SWIG_fail;
15553 }
15554 {
15555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15556 }
15557 return resultobj;
15558 fail:
15559 return NULL;
15560 }
15561
15562
15563 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15564 PyObject *resultobj = 0;
15565 wxJoystick *arg1 = (wxJoystick *) 0 ;
15566 int 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_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15576 }
15577 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15578 {
15579 PyThreadState* __tstate = wxPyBeginAllowThreads();
15580 result = (int)(arg1)->GetNumberJoysticks();
15581 wxPyEndAllowThreads(__tstate);
15582 if (PyErr_Occurred()) SWIG_fail;
15583 }
15584 resultobj = SWIG_From_int(static_cast< int >(result));
15585 return resultobj;
15586 fail:
15587 return NULL;
15588 }
15589
15590
15591 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15592 PyObject *resultobj = 0;
15593 wxJoystick *arg1 = (wxJoystick *) 0 ;
15594 int result;
15595 void *argp1 = 0 ;
15596 int res1 = 0 ;
15597 PyObject *swig_obj[1] ;
15598
15599 if (!args) SWIG_fail;
15600 swig_obj[0] = args;
15601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15602 if (!SWIG_IsOK(res1)) {
15603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15604 }
15605 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15606 {
15607 PyThreadState* __tstate = wxPyBeginAllowThreads();
15608 result = (int)(arg1)->GetManufacturerId();
15609 wxPyEndAllowThreads(__tstate);
15610 if (PyErr_Occurred()) SWIG_fail;
15611 }
15612 resultobj = SWIG_From_int(static_cast< int >(result));
15613 return resultobj;
15614 fail:
15615 return NULL;
15616 }
15617
15618
15619 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15620 PyObject *resultobj = 0;
15621 wxJoystick *arg1 = (wxJoystick *) 0 ;
15622 int result;
15623 void *argp1 = 0 ;
15624 int res1 = 0 ;
15625 PyObject *swig_obj[1] ;
15626
15627 if (!args) SWIG_fail;
15628 swig_obj[0] = args;
15629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15630 if (!SWIG_IsOK(res1)) {
15631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15632 }
15633 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15634 {
15635 PyThreadState* __tstate = wxPyBeginAllowThreads();
15636 result = (int)(arg1)->GetProductId();
15637 wxPyEndAllowThreads(__tstate);
15638 if (PyErr_Occurred()) SWIG_fail;
15639 }
15640 resultobj = SWIG_From_int(static_cast< int >(result));
15641 return resultobj;
15642 fail:
15643 return NULL;
15644 }
15645
15646
15647 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15648 PyObject *resultobj = 0;
15649 wxJoystick *arg1 = (wxJoystick *) 0 ;
15650 wxString result;
15651 void *argp1 = 0 ;
15652 int res1 = 0 ;
15653 PyObject *swig_obj[1] ;
15654
15655 if (!args) SWIG_fail;
15656 swig_obj[0] = args;
15657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15658 if (!SWIG_IsOK(res1)) {
15659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15660 }
15661 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 result = (arg1)->GetProductName();
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 {
15669 #if wxUSE_UNICODE
15670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15671 #else
15672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15673 #endif
15674 }
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15682 PyObject *resultobj = 0;
15683 wxJoystick *arg1 = (wxJoystick *) 0 ;
15684 int result;
15685 void *argp1 = 0 ;
15686 int res1 = 0 ;
15687 PyObject *swig_obj[1] ;
15688
15689 if (!args) SWIG_fail;
15690 swig_obj[0] = args;
15691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15692 if (!SWIG_IsOK(res1)) {
15693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15694 }
15695 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 result = (int)(arg1)->GetXMin();
15699 wxPyEndAllowThreads(__tstate);
15700 if (PyErr_Occurred()) SWIG_fail;
15701 }
15702 resultobj = SWIG_From_int(static_cast< int >(result));
15703 return resultobj;
15704 fail:
15705 return NULL;
15706 }
15707
15708
15709 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15710 PyObject *resultobj = 0;
15711 wxJoystick *arg1 = (wxJoystick *) 0 ;
15712 int result;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 PyObject *swig_obj[1] ;
15716
15717 if (!args) SWIG_fail;
15718 swig_obj[0] = args;
15719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15720 if (!SWIG_IsOK(res1)) {
15721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15722 }
15723 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 result = (int)(arg1)->GetYMin();
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 resultobj = SWIG_From_int(static_cast< int >(result));
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15738 PyObject *resultobj = 0;
15739 wxJoystick *arg1 = (wxJoystick *) 0 ;
15740 int result;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 PyObject *swig_obj[1] ;
15744
15745 if (!args) SWIG_fail;
15746 swig_obj[0] = args;
15747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15750 }
15751 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 result = (int)(arg1)->GetZMin();
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 resultobj = SWIG_From_int(static_cast< int >(result));
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxJoystick *arg1 = (wxJoystick *) 0 ;
15768 int result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15778 }
15779 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = (int)(arg1)->GetXMax();
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_From_int(static_cast< int >(result));
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15794 PyObject *resultobj = 0;
15795 wxJoystick *arg1 = (wxJoystick *) 0 ;
15796 int result;
15797 void *argp1 = 0 ;
15798 int res1 = 0 ;
15799 PyObject *swig_obj[1] ;
15800
15801 if (!args) SWIG_fail;
15802 swig_obj[0] = args;
15803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15804 if (!SWIG_IsOK(res1)) {
15805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15806 }
15807 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (int)(arg1)->GetYMax();
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 resultobj = SWIG_From_int(static_cast< int >(result));
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 wxJoystick *arg1 = (wxJoystick *) 0 ;
15824 int result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 PyObject *swig_obj[1] ;
15828
15829 if (!args) SWIG_fail;
15830 swig_obj[0] = args;
15831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15834 }
15835 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (int)(arg1)->GetZMax();
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 resultobj = SWIG_From_int(static_cast< int >(result));
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15850 PyObject *resultobj = 0;
15851 wxJoystick *arg1 = (wxJoystick *) 0 ;
15852 int result;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 PyObject *swig_obj[1] ;
15856
15857 if (!args) SWIG_fail;
15858 swig_obj[0] = args;
15859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15860 if (!SWIG_IsOK(res1)) {
15861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15862 }
15863 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = (int)(arg1)->GetNumberButtons();
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 resultobj = SWIG_From_int(static_cast< int >(result));
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15878 PyObject *resultobj = 0;
15879 wxJoystick *arg1 = (wxJoystick *) 0 ;
15880 int result;
15881 void *argp1 = 0 ;
15882 int res1 = 0 ;
15883 PyObject *swig_obj[1] ;
15884
15885 if (!args) SWIG_fail;
15886 swig_obj[0] = args;
15887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15888 if (!SWIG_IsOK(res1)) {
15889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15890 }
15891 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (int)(arg1)->GetNumberAxes();
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_From_int(static_cast< int >(result));
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15906 PyObject *resultobj = 0;
15907 wxJoystick *arg1 = (wxJoystick *) 0 ;
15908 int result;
15909 void *argp1 = 0 ;
15910 int res1 = 0 ;
15911 PyObject *swig_obj[1] ;
15912
15913 if (!args) SWIG_fail;
15914 swig_obj[0] = args;
15915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15916 if (!SWIG_IsOK(res1)) {
15917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15918 }
15919 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 result = (int)(arg1)->GetMaxButtons();
15923 wxPyEndAllowThreads(__tstate);
15924 if (PyErr_Occurred()) SWIG_fail;
15925 }
15926 resultobj = SWIG_From_int(static_cast< int >(result));
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15934 PyObject *resultobj = 0;
15935 wxJoystick *arg1 = (wxJoystick *) 0 ;
15936 int result;
15937 void *argp1 = 0 ;
15938 int res1 = 0 ;
15939 PyObject *swig_obj[1] ;
15940
15941 if (!args) SWIG_fail;
15942 swig_obj[0] = args;
15943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15944 if (!SWIG_IsOK(res1)) {
15945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15946 }
15947 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (int)(arg1)->GetMaxAxes();
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_From_int(static_cast< int >(result));
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15962 PyObject *resultobj = 0;
15963 wxJoystick *arg1 = (wxJoystick *) 0 ;
15964 int result;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 PyObject *swig_obj[1] ;
15968
15969 if (!args) SWIG_fail;
15970 swig_obj[0] = args;
15971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15974 }
15975 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15976 {
15977 PyThreadState* __tstate = wxPyBeginAllowThreads();
15978 result = (int)(arg1)->GetPollingMin();
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 resultobj = SWIG_From_int(static_cast< int >(result));
15983 return resultobj;
15984 fail:
15985 return NULL;
15986 }
15987
15988
15989 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15990 PyObject *resultobj = 0;
15991 wxJoystick *arg1 = (wxJoystick *) 0 ;
15992 int result;
15993 void *argp1 = 0 ;
15994 int res1 = 0 ;
15995 PyObject *swig_obj[1] ;
15996
15997 if (!args) SWIG_fail;
15998 swig_obj[0] = args;
15999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16002 }
16003 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 result = (int)(arg1)->GetPollingMax();
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 resultobj = SWIG_From_int(static_cast< int >(result));
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16018 PyObject *resultobj = 0;
16019 wxJoystick *arg1 = (wxJoystick *) 0 ;
16020 int result;
16021 void *argp1 = 0 ;
16022 int res1 = 0 ;
16023 PyObject *swig_obj[1] ;
16024
16025 if (!args) SWIG_fail;
16026 swig_obj[0] = args;
16027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16028 if (!SWIG_IsOK(res1)) {
16029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16030 }
16031 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16032 {
16033 PyThreadState* __tstate = wxPyBeginAllowThreads();
16034 result = (int)(arg1)->GetRudderMin();
16035 wxPyEndAllowThreads(__tstate);
16036 if (PyErr_Occurred()) SWIG_fail;
16037 }
16038 resultobj = SWIG_From_int(static_cast< int >(result));
16039 return resultobj;
16040 fail:
16041 return NULL;
16042 }
16043
16044
16045 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16046 PyObject *resultobj = 0;
16047 wxJoystick *arg1 = (wxJoystick *) 0 ;
16048 int result;
16049 void *argp1 = 0 ;
16050 int res1 = 0 ;
16051 PyObject *swig_obj[1] ;
16052
16053 if (!args) SWIG_fail;
16054 swig_obj[0] = args;
16055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16056 if (!SWIG_IsOK(res1)) {
16057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16058 }
16059 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16060 {
16061 PyThreadState* __tstate = wxPyBeginAllowThreads();
16062 result = (int)(arg1)->GetRudderMax();
16063 wxPyEndAllowThreads(__tstate);
16064 if (PyErr_Occurred()) SWIG_fail;
16065 }
16066 resultobj = SWIG_From_int(static_cast< int >(result));
16067 return resultobj;
16068 fail:
16069 return NULL;
16070 }
16071
16072
16073 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16074 PyObject *resultobj = 0;
16075 wxJoystick *arg1 = (wxJoystick *) 0 ;
16076 int result;
16077 void *argp1 = 0 ;
16078 int res1 = 0 ;
16079 PyObject *swig_obj[1] ;
16080
16081 if (!args) SWIG_fail;
16082 swig_obj[0] = args;
16083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16084 if (!SWIG_IsOK(res1)) {
16085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16086 }
16087 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16088 {
16089 PyThreadState* __tstate = wxPyBeginAllowThreads();
16090 result = (int)(arg1)->GetUMin();
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 resultobj = SWIG_From_int(static_cast< int >(result));
16095 return resultobj;
16096 fail:
16097 return NULL;
16098 }
16099
16100
16101 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16102 PyObject *resultobj = 0;
16103 wxJoystick *arg1 = (wxJoystick *) 0 ;
16104 int result;
16105 void *argp1 = 0 ;
16106 int res1 = 0 ;
16107 PyObject *swig_obj[1] ;
16108
16109 if (!args) SWIG_fail;
16110 swig_obj[0] = args;
16111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16112 if (!SWIG_IsOK(res1)) {
16113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16114 }
16115 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16116 {
16117 PyThreadState* __tstate = wxPyBeginAllowThreads();
16118 result = (int)(arg1)->GetUMax();
16119 wxPyEndAllowThreads(__tstate);
16120 if (PyErr_Occurred()) SWIG_fail;
16121 }
16122 resultobj = SWIG_From_int(static_cast< int >(result));
16123 return resultobj;
16124 fail:
16125 return NULL;
16126 }
16127
16128
16129 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16130 PyObject *resultobj = 0;
16131 wxJoystick *arg1 = (wxJoystick *) 0 ;
16132 int result;
16133 void *argp1 = 0 ;
16134 int res1 = 0 ;
16135 PyObject *swig_obj[1] ;
16136
16137 if (!args) SWIG_fail;
16138 swig_obj[0] = args;
16139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16140 if (!SWIG_IsOK(res1)) {
16141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16142 }
16143 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16144 {
16145 PyThreadState* __tstate = wxPyBeginAllowThreads();
16146 result = (int)(arg1)->GetVMin();
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 resultobj = SWIG_From_int(static_cast< int >(result));
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16158 PyObject *resultobj = 0;
16159 wxJoystick *arg1 = (wxJoystick *) 0 ;
16160 int result;
16161 void *argp1 = 0 ;
16162 int res1 = 0 ;
16163 PyObject *swig_obj[1] ;
16164
16165 if (!args) SWIG_fail;
16166 swig_obj[0] = args;
16167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16168 if (!SWIG_IsOK(res1)) {
16169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16170 }
16171 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16172 {
16173 PyThreadState* __tstate = wxPyBeginAllowThreads();
16174 result = (int)(arg1)->GetVMax();
16175 wxPyEndAllowThreads(__tstate);
16176 if (PyErr_Occurred()) SWIG_fail;
16177 }
16178 resultobj = SWIG_From_int(static_cast< int >(result));
16179 return resultobj;
16180 fail:
16181 return NULL;
16182 }
16183
16184
16185 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16186 PyObject *resultobj = 0;
16187 wxJoystick *arg1 = (wxJoystick *) 0 ;
16188 bool result;
16189 void *argp1 = 0 ;
16190 int res1 = 0 ;
16191 PyObject *swig_obj[1] ;
16192
16193 if (!args) SWIG_fail;
16194 swig_obj[0] = args;
16195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16196 if (!SWIG_IsOK(res1)) {
16197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16198 }
16199 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16200 {
16201 PyThreadState* __tstate = wxPyBeginAllowThreads();
16202 result = (bool)(arg1)->HasRudder();
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 {
16207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16208 }
16209 return resultobj;
16210 fail:
16211 return NULL;
16212 }
16213
16214
16215 SWIGINTERN PyObject *_wrap_Joystick_HasZ(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_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16228 }
16229 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16230 {
16231 PyThreadState* __tstate = wxPyBeginAllowThreads();
16232 result = (bool)(arg1)->HasZ();
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_HasU(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_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16258 }
16259 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16260 {
16261 PyThreadState* __tstate = wxPyBeginAllowThreads();
16262 result = (bool)(arg1)->HasU();
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_HasV(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_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16288 }
16289 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16290 {
16291 PyThreadState* __tstate = wxPyBeginAllowThreads();
16292 result = (bool)(arg1)->HasV();
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_HasPOV(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_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16318 }
16319 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16320 {
16321 PyThreadState* __tstate = wxPyBeginAllowThreads();
16322 result = (bool)(arg1)->HasPOV();
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_HasPOV4Dir(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_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16348 }
16349 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16350 {
16351 PyThreadState* __tstate = wxPyBeginAllowThreads();
16352 result = (bool)(arg1)->HasPOV4Dir();
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_HasPOVCTS(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_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16378 }
16379 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16380 {
16381 PyThreadState* __tstate = wxPyBeginAllowThreads();
16382 result = (bool)(arg1)->HasPOVCTS();
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_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj = 0;
16397 wxJoystick *arg1 = (wxJoystick *) 0 ;
16398 wxWindow *arg2 = (wxWindow *) 0 ;
16399 int arg3 = (int) 0 ;
16400 bool result;
16401 void *argp1 = 0 ;
16402 int res1 = 0 ;
16403 void *argp2 = 0 ;
16404 int res2 = 0 ;
16405 int val3 ;
16406 int ecode3 = 0 ;
16407 PyObject * obj0 = 0 ;
16408 PyObject * obj1 = 0 ;
16409 PyObject * obj2 = 0 ;
16410 char * kwnames[] = {
16411 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16412 };
16413
16414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16416 if (!SWIG_IsOK(res1)) {
16417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16418 }
16419 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16420 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16421 if (!SWIG_IsOK(res2)) {
16422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16423 }
16424 arg2 = reinterpret_cast< wxWindow * >(argp2);
16425 if (obj2) {
16426 ecode3 = SWIG_AsVal_int(obj2, &val3);
16427 if (!SWIG_IsOK(ecode3)) {
16428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16429 }
16430 arg3 = static_cast< int >(val3);
16431 }
16432 {
16433 PyThreadState* __tstate = wxPyBeginAllowThreads();
16434 result = (bool)(arg1)->SetCapture(arg2,arg3);
16435 wxPyEndAllowThreads(__tstate);
16436 if (PyErr_Occurred()) SWIG_fail;
16437 }
16438 {
16439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16440 }
16441 return resultobj;
16442 fail:
16443 return NULL;
16444 }
16445
16446
16447 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16448 PyObject *resultobj = 0;
16449 wxJoystick *arg1 = (wxJoystick *) 0 ;
16450 bool result;
16451 void *argp1 = 0 ;
16452 int res1 = 0 ;
16453 PyObject *swig_obj[1] ;
16454
16455 if (!args) SWIG_fail;
16456 swig_obj[0] = args;
16457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16458 if (!SWIG_IsOK(res1)) {
16459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16460 }
16461 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16462 {
16463 PyThreadState* __tstate = wxPyBeginAllowThreads();
16464 result = (bool)(arg1)->ReleaseCapture();
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 *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16478 PyObject *obj;
16479 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16480 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16481 return SWIG_Py_Void();
16482 }
16483
16484 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16485 return SWIG_Python_InitShadowInstance(args);
16486 }
16487
16488 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16489 PyObject *resultobj = 0;
16490 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16491 int arg2 = (int) 0 ;
16492 int arg3 = (int) wxJOYSTICK1 ;
16493 int arg4 = (int) 0 ;
16494 wxJoystickEvent *result = 0 ;
16495 int val1 ;
16496 int ecode1 = 0 ;
16497 int val2 ;
16498 int ecode2 = 0 ;
16499 int val3 ;
16500 int ecode3 = 0 ;
16501 int val4 ;
16502 int ecode4 = 0 ;
16503 PyObject * obj0 = 0 ;
16504 PyObject * obj1 = 0 ;
16505 PyObject * obj2 = 0 ;
16506 PyObject * obj3 = 0 ;
16507 char * kwnames[] = {
16508 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16509 };
16510
16511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16512 if (obj0) {
16513 ecode1 = SWIG_AsVal_int(obj0, &val1);
16514 if (!SWIG_IsOK(ecode1)) {
16515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16516 }
16517 arg1 = static_cast< wxEventType >(val1);
16518 }
16519 if (obj1) {
16520 ecode2 = SWIG_AsVal_int(obj1, &val2);
16521 if (!SWIG_IsOK(ecode2)) {
16522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16523 }
16524 arg2 = static_cast< int >(val2);
16525 }
16526 if (obj2) {
16527 ecode3 = SWIG_AsVal_int(obj2, &val3);
16528 if (!SWIG_IsOK(ecode3)) {
16529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16530 }
16531 arg3 = static_cast< int >(val3);
16532 }
16533 if (obj3) {
16534 ecode4 = SWIG_AsVal_int(obj3, &val4);
16535 if (!SWIG_IsOK(ecode4)) {
16536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16537 }
16538 arg4 = static_cast< int >(val4);
16539 }
16540 {
16541 PyThreadState* __tstate = wxPyBeginAllowThreads();
16542 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16543 wxPyEndAllowThreads(__tstate);
16544 if (PyErr_Occurred()) SWIG_fail;
16545 }
16546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16547 return resultobj;
16548 fail:
16549 return NULL;
16550 }
16551
16552
16553 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16554 PyObject *resultobj = 0;
16555 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16556 wxPoint result;
16557 void *argp1 = 0 ;
16558 int res1 = 0 ;
16559 PyObject *swig_obj[1] ;
16560
16561 if (!args) SWIG_fail;
16562 swig_obj[0] = args;
16563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16564 if (!SWIG_IsOK(res1)) {
16565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16566 }
16567 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16575 return resultobj;
16576 fail:
16577 return NULL;
16578 }
16579
16580
16581 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16582 PyObject *resultobj = 0;
16583 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16584 int result;
16585 void *argp1 = 0 ;
16586 int res1 = 0 ;
16587 PyObject *swig_obj[1] ;
16588
16589 if (!args) SWIG_fail;
16590 swig_obj[0] = args;
16591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16592 if (!SWIG_IsOK(res1)) {
16593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16594 }
16595 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 resultobj = SWIG_From_int(static_cast< int >(result));
16603 return resultobj;
16604 fail:
16605 return NULL;
16606 }
16607
16608
16609 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16610 PyObject *resultobj = 0;
16611 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16612 int result;
16613 void *argp1 = 0 ;
16614 int res1 = 0 ;
16615 PyObject *swig_obj[1] ;
16616
16617 if (!args) SWIG_fail;
16618 swig_obj[0] = args;
16619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16620 if (!SWIG_IsOK(res1)) {
16621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16622 }
16623 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16624 {
16625 PyThreadState* __tstate = wxPyBeginAllowThreads();
16626 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 resultobj = SWIG_From_int(static_cast< int >(result));
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16638 PyObject *resultobj = 0;
16639 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16640 int result;
16641 void *argp1 = 0 ;
16642 int res1 = 0 ;
16643 PyObject *swig_obj[1] ;
16644
16645 if (!args) SWIG_fail;
16646 swig_obj[0] = args;
16647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16648 if (!SWIG_IsOK(res1)) {
16649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16650 }
16651 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16655 wxPyEndAllowThreads(__tstate);
16656 if (PyErr_Occurred()) SWIG_fail;
16657 }
16658 resultobj = SWIG_From_int(static_cast< int >(result));
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16666 PyObject *resultobj = 0;
16667 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16668 int result;
16669 void *argp1 = 0 ;
16670 int res1 = 0 ;
16671 PyObject *swig_obj[1] ;
16672
16673 if (!args) SWIG_fail;
16674 swig_obj[0] = args;
16675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16676 if (!SWIG_IsOK(res1)) {
16677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16678 }
16679 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 resultobj = SWIG_From_int(static_cast< int >(result));
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16694 PyObject *resultobj = 0;
16695 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16696 int arg2 ;
16697 void *argp1 = 0 ;
16698 int res1 = 0 ;
16699 int val2 ;
16700 int ecode2 = 0 ;
16701 PyObject * obj0 = 0 ;
16702 PyObject * obj1 = 0 ;
16703 char * kwnames[] = {
16704 (char *) "self",(char *) "stick", NULL
16705 };
16706
16707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16709 if (!SWIG_IsOK(res1)) {
16710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16711 }
16712 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16713 ecode2 = SWIG_AsVal_int(obj1, &val2);
16714 if (!SWIG_IsOK(ecode2)) {
16715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16716 }
16717 arg2 = static_cast< int >(val2);
16718 {
16719 PyThreadState* __tstate = wxPyBeginAllowThreads();
16720 (arg1)->SetJoystick(arg2);
16721 wxPyEndAllowThreads(__tstate);
16722 if (PyErr_Occurred()) SWIG_fail;
16723 }
16724 resultobj = SWIG_Py_Void();
16725 return resultobj;
16726 fail:
16727 return NULL;
16728 }
16729
16730
16731 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16732 PyObject *resultobj = 0;
16733 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16734 int arg2 ;
16735 void *argp1 = 0 ;
16736 int res1 = 0 ;
16737 int val2 ;
16738 int ecode2 = 0 ;
16739 PyObject * obj0 = 0 ;
16740 PyObject * obj1 = 0 ;
16741 char * kwnames[] = {
16742 (char *) "self",(char *) "state", NULL
16743 };
16744
16745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16747 if (!SWIG_IsOK(res1)) {
16748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16749 }
16750 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16751 ecode2 = SWIG_AsVal_int(obj1, &val2);
16752 if (!SWIG_IsOK(ecode2)) {
16753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16754 }
16755 arg2 = static_cast< int >(val2);
16756 {
16757 PyThreadState* __tstate = wxPyBeginAllowThreads();
16758 (arg1)->SetButtonState(arg2);
16759 wxPyEndAllowThreads(__tstate);
16760 if (PyErr_Occurred()) SWIG_fail;
16761 }
16762 resultobj = SWIG_Py_Void();
16763 return resultobj;
16764 fail:
16765 return NULL;
16766 }
16767
16768
16769 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16770 PyObject *resultobj = 0;
16771 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16772 int arg2 ;
16773 void *argp1 = 0 ;
16774 int res1 = 0 ;
16775 int val2 ;
16776 int ecode2 = 0 ;
16777 PyObject * obj0 = 0 ;
16778 PyObject * obj1 = 0 ;
16779 char * kwnames[] = {
16780 (char *) "self",(char *) "change", NULL
16781 };
16782
16783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16785 if (!SWIG_IsOK(res1)) {
16786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16787 }
16788 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16789 ecode2 = SWIG_AsVal_int(obj1, &val2);
16790 if (!SWIG_IsOK(ecode2)) {
16791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16792 }
16793 arg2 = static_cast< int >(val2);
16794 {
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 (arg1)->SetButtonChange(arg2);
16797 wxPyEndAllowThreads(__tstate);
16798 if (PyErr_Occurred()) SWIG_fail;
16799 }
16800 resultobj = SWIG_Py_Void();
16801 return resultobj;
16802 fail:
16803 return NULL;
16804 }
16805
16806
16807 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16808 PyObject *resultobj = 0;
16809 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16810 wxPoint *arg2 = 0 ;
16811 void *argp1 = 0 ;
16812 int res1 = 0 ;
16813 wxPoint temp2 ;
16814 PyObject * obj0 = 0 ;
16815 PyObject * obj1 = 0 ;
16816 char * kwnames[] = {
16817 (char *) "self",(char *) "pos", NULL
16818 };
16819
16820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16822 if (!SWIG_IsOK(res1)) {
16823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16824 }
16825 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16826 {
16827 arg2 = &temp2;
16828 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16829 }
16830 {
16831 PyThreadState* __tstate = wxPyBeginAllowThreads();
16832 (arg1)->SetPosition((wxPoint const &)*arg2);
16833 wxPyEndAllowThreads(__tstate);
16834 if (PyErr_Occurred()) SWIG_fail;
16835 }
16836 resultobj = SWIG_Py_Void();
16837 return resultobj;
16838 fail:
16839 return NULL;
16840 }
16841
16842
16843 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16844 PyObject *resultobj = 0;
16845 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16846 int arg2 ;
16847 void *argp1 = 0 ;
16848 int res1 = 0 ;
16849 int val2 ;
16850 int ecode2 = 0 ;
16851 PyObject * obj0 = 0 ;
16852 PyObject * obj1 = 0 ;
16853 char * kwnames[] = {
16854 (char *) "self",(char *) "zPos", NULL
16855 };
16856
16857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16859 if (!SWIG_IsOK(res1)) {
16860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16861 }
16862 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16863 ecode2 = SWIG_AsVal_int(obj1, &val2);
16864 if (!SWIG_IsOK(ecode2)) {
16865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16866 }
16867 arg2 = static_cast< int >(val2);
16868 {
16869 PyThreadState* __tstate = wxPyBeginAllowThreads();
16870 (arg1)->SetZPosition(arg2);
16871 wxPyEndAllowThreads(__tstate);
16872 if (PyErr_Occurred()) SWIG_fail;
16873 }
16874 resultobj = SWIG_Py_Void();
16875 return resultobj;
16876 fail:
16877 return NULL;
16878 }
16879
16880
16881 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16882 PyObject *resultobj = 0;
16883 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16884 bool result;
16885 void *argp1 = 0 ;
16886 int res1 = 0 ;
16887 PyObject *swig_obj[1] ;
16888
16889 if (!args) SWIG_fail;
16890 swig_obj[0] = args;
16891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16892 if (!SWIG_IsOK(res1)) {
16893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16894 }
16895 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16896 {
16897 PyThreadState* __tstate = wxPyBeginAllowThreads();
16898 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16899 wxPyEndAllowThreads(__tstate);
16900 if (PyErr_Occurred()) SWIG_fail;
16901 }
16902 {
16903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16904 }
16905 return resultobj;
16906 fail:
16907 return NULL;
16908 }
16909
16910
16911 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(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_IsMove" "', 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)->IsMove();
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_IsZMove(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_IsZMove" "', 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)->IsZMove();
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_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16972 PyObject *resultobj = 0;
16973 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16974 int arg2 = (int) wxJOY_BUTTON_ANY ;
16975 bool result;
16976 void *argp1 = 0 ;
16977 int res1 = 0 ;
16978 int val2 ;
16979 int ecode2 = 0 ;
16980 PyObject * obj0 = 0 ;
16981 PyObject * obj1 = 0 ;
16982 char * kwnames[] = {
16983 (char *) "self",(char *) "but", NULL
16984 };
16985
16986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16988 if (!SWIG_IsOK(res1)) {
16989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16990 }
16991 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16992 if (obj1) {
16993 ecode2 = SWIG_AsVal_int(obj1, &val2);
16994 if (!SWIG_IsOK(ecode2)) {
16995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16996 }
16997 arg2 = static_cast< int >(val2);
16998 }
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 {
17006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17007 }
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj = 0;
17016 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17017 int arg2 = (int) wxJOY_BUTTON_ANY ;
17018 bool result;
17019 void *argp1 = 0 ;
17020 int res1 = 0 ;
17021 int val2 ;
17022 int ecode2 = 0 ;
17023 PyObject * obj0 = 0 ;
17024 PyObject * obj1 = 0 ;
17025 char * kwnames[] = {
17026 (char *) "self",(char *) "but", NULL
17027 };
17028
17029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17031 if (!SWIG_IsOK(res1)) {
17032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17033 }
17034 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17035 if (obj1) {
17036 ecode2 = SWIG_AsVal_int(obj1, &val2);
17037 if (!SWIG_IsOK(ecode2)) {
17038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17039 }
17040 arg2 = static_cast< int >(val2);
17041 }
17042 {
17043 PyThreadState* __tstate = wxPyBeginAllowThreads();
17044 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17045 wxPyEndAllowThreads(__tstate);
17046 if (PyErr_Occurred()) SWIG_fail;
17047 }
17048 {
17049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17050 }
17051 return resultobj;
17052 fail:
17053 return NULL;
17054 }
17055
17056
17057 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17058 PyObject *resultobj = 0;
17059 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17060 int arg2 = (int) wxJOY_BUTTON_ANY ;
17061 bool result;
17062 void *argp1 = 0 ;
17063 int res1 = 0 ;
17064 int val2 ;
17065 int ecode2 = 0 ;
17066 PyObject * obj0 = 0 ;
17067 PyObject * obj1 = 0 ;
17068 char * kwnames[] = {
17069 (char *) "self",(char *) "but", NULL
17070 };
17071
17072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17074 if (!SWIG_IsOK(res1)) {
17075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17076 }
17077 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17078 if (obj1) {
17079 ecode2 = SWIG_AsVal_int(obj1, &val2);
17080 if (!SWIG_IsOK(ecode2)) {
17081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17082 }
17083 arg2 = static_cast< int >(val2);
17084 }
17085 {
17086 PyThreadState* __tstate = wxPyBeginAllowThreads();
17087 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17088 wxPyEndAllowThreads(__tstate);
17089 if (PyErr_Occurred()) SWIG_fail;
17090 }
17091 {
17092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17093 }
17094 return resultobj;
17095 fail:
17096 return NULL;
17097 }
17098
17099
17100 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17101 PyObject *obj;
17102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17103 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17104 return SWIG_Py_Void();
17105 }
17106
17107 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17108 return SWIG_Python_InitShadowInstance(args);
17109 }
17110
17111 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17112 PyObject *resultobj = 0;
17113 wxString const &arg1_defvalue = wxPyEmptyString ;
17114 wxString *arg1 = (wxString *) &arg1_defvalue ;
17115 wxSound *result = 0 ;
17116 bool temp1 = false ;
17117 PyObject * obj0 = 0 ;
17118 char * kwnames[] = {
17119 (char *) "fileName", NULL
17120 };
17121
17122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17123 if (obj0) {
17124 {
17125 arg1 = wxString_in_helper(obj0);
17126 if (arg1 == NULL) SWIG_fail;
17127 temp1 = true;
17128 }
17129 }
17130 {
17131 if (!wxPyCheckForApp()) SWIG_fail;
17132 PyThreadState* __tstate = wxPyBeginAllowThreads();
17133 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17134 wxPyEndAllowThreads(__tstate);
17135 if (PyErr_Occurred()) SWIG_fail;
17136 }
17137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17138 {
17139 if (temp1)
17140 delete arg1;
17141 }
17142 return resultobj;
17143 fail:
17144 {
17145 if (temp1)
17146 delete arg1;
17147 }
17148 return NULL;
17149 }
17150
17151
17152 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj = 0;
17154 PyObject *arg1 = (PyObject *) 0 ;
17155 wxSound *result = 0 ;
17156 PyObject * obj0 = 0 ;
17157 char * kwnames[] = {
17158 (char *) "data", NULL
17159 };
17160
17161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17162 arg1 = obj0;
17163 {
17164 if (!wxPyCheckForApp()) SWIG_fail;
17165 PyThreadState* __tstate = wxPyBeginAllowThreads();
17166 result = (wxSound *)new_wxSound(arg1);
17167 wxPyEndAllowThreads(__tstate);
17168 if (PyErr_Occurred()) SWIG_fail;
17169 }
17170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17171 return resultobj;
17172 fail:
17173 return NULL;
17174 }
17175
17176
17177 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17178 PyObject *resultobj = 0;
17179 wxSound *arg1 = (wxSound *) 0 ;
17180 void *argp1 = 0 ;
17181 int res1 = 0 ;
17182 PyObject *swig_obj[1] ;
17183
17184 if (!args) SWIG_fail;
17185 swig_obj[0] = args;
17186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17187 if (!SWIG_IsOK(res1)) {
17188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17189 }
17190 arg1 = reinterpret_cast< wxSound * >(argp1);
17191 {
17192 PyThreadState* __tstate = wxPyBeginAllowThreads();
17193 delete arg1;
17194
17195 wxPyEndAllowThreads(__tstate);
17196 if (PyErr_Occurred()) SWIG_fail;
17197 }
17198 resultobj = SWIG_Py_Void();
17199 return resultobj;
17200 fail:
17201 return NULL;
17202 }
17203
17204
17205 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17206 PyObject *resultobj = 0;
17207 wxSound *arg1 = (wxSound *) 0 ;
17208 wxString *arg2 = 0 ;
17209 bool result;
17210 void *argp1 = 0 ;
17211 int res1 = 0 ;
17212 bool temp2 = false ;
17213 PyObject * obj0 = 0 ;
17214 PyObject * obj1 = 0 ;
17215 char * kwnames[] = {
17216 (char *) "self",(char *) "fileName", NULL
17217 };
17218
17219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17221 if (!SWIG_IsOK(res1)) {
17222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17223 }
17224 arg1 = reinterpret_cast< wxSound * >(argp1);
17225 {
17226 arg2 = wxString_in_helper(obj1);
17227 if (arg2 == NULL) SWIG_fail;
17228 temp2 = true;
17229 }
17230 {
17231 PyThreadState* __tstate = wxPyBeginAllowThreads();
17232 result = (bool)(arg1)->Create((wxString const &)*arg2);
17233 wxPyEndAllowThreads(__tstate);
17234 if (PyErr_Occurred()) SWIG_fail;
17235 }
17236 {
17237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17238 }
17239 {
17240 if (temp2)
17241 delete arg2;
17242 }
17243 return resultobj;
17244 fail:
17245 {
17246 if (temp2)
17247 delete arg2;
17248 }
17249 return NULL;
17250 }
17251
17252
17253 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17254 PyObject *resultobj = 0;
17255 wxSound *arg1 = (wxSound *) 0 ;
17256 PyObject *arg2 = (PyObject *) 0 ;
17257 bool result;
17258 void *argp1 = 0 ;
17259 int res1 = 0 ;
17260 PyObject * obj0 = 0 ;
17261 PyObject * obj1 = 0 ;
17262 char * kwnames[] = {
17263 (char *) "self",(char *) "data", NULL
17264 };
17265
17266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17268 if (!SWIG_IsOK(res1)) {
17269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17270 }
17271 arg1 = reinterpret_cast< wxSound * >(argp1);
17272 arg2 = obj1;
17273 {
17274 PyThreadState* __tstate = wxPyBeginAllowThreads();
17275 result = (bool)wxSound_CreateFromData(arg1,arg2);
17276 wxPyEndAllowThreads(__tstate);
17277 if (PyErr_Occurred()) SWIG_fail;
17278 }
17279 {
17280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17281 }
17282 return resultobj;
17283 fail:
17284 return NULL;
17285 }
17286
17287
17288 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17289 PyObject *resultobj = 0;
17290 wxSound *arg1 = (wxSound *) 0 ;
17291 bool result;
17292 void *argp1 = 0 ;
17293 int res1 = 0 ;
17294 PyObject *swig_obj[1] ;
17295
17296 if (!args) SWIG_fail;
17297 swig_obj[0] = args;
17298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17299 if (!SWIG_IsOK(res1)) {
17300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17301 }
17302 arg1 = reinterpret_cast< wxSound * >(argp1);
17303 {
17304 PyThreadState* __tstate = wxPyBeginAllowThreads();
17305 result = (bool)(arg1)->IsOk();
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_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17319 PyObject *resultobj = 0;
17320 wxSound *arg1 = (wxSound *) 0 ;
17321 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17322 bool result;
17323 void *argp1 = 0 ;
17324 int res1 = 0 ;
17325 unsigned int val2 ;
17326 int ecode2 = 0 ;
17327 PyObject * obj0 = 0 ;
17328 PyObject * obj1 = 0 ;
17329 char * kwnames[] = {
17330 (char *) "self",(char *) "flags", NULL
17331 };
17332
17333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17335 if (!SWIG_IsOK(res1)) {
17336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17337 }
17338 arg1 = reinterpret_cast< wxSound * >(argp1);
17339 if (obj1) {
17340 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17341 if (!SWIG_IsOK(ecode2)) {
17342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17343 }
17344 arg2 = static_cast< unsigned int >(val2);
17345 }
17346 {
17347 if (!wxPyCheckForApp()) SWIG_fail;
17348 PyThreadState* __tstate = wxPyBeginAllowThreads();
17349 result = (bool)((wxSound const *)arg1)->Play(arg2);
17350 wxPyEndAllowThreads(__tstate);
17351 if (PyErr_Occurred()) SWIG_fail;
17352 }
17353 {
17354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17355 }
17356 return resultobj;
17357 fail:
17358 return NULL;
17359 }
17360
17361
17362 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17363 PyObject *resultobj = 0;
17364 wxString *arg1 = 0 ;
17365 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17366 bool result;
17367 bool temp1 = false ;
17368 unsigned int val2 ;
17369 int ecode2 = 0 ;
17370 PyObject * obj0 = 0 ;
17371 PyObject * obj1 = 0 ;
17372 char * kwnames[] = {
17373 (char *) "filename",(char *) "flags", NULL
17374 };
17375
17376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17377 {
17378 arg1 = wxString_in_helper(obj0);
17379 if (arg1 == NULL) SWIG_fail;
17380 temp1 = true;
17381 }
17382 if (obj1) {
17383 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17384 if (!SWIG_IsOK(ecode2)) {
17385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17386 }
17387 arg2 = static_cast< unsigned int >(val2);
17388 }
17389 {
17390 if (!wxPyCheckForApp()) SWIG_fail;
17391 PyThreadState* __tstate = wxPyBeginAllowThreads();
17392 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17393 wxPyEndAllowThreads(__tstate);
17394 if (PyErr_Occurred()) SWIG_fail;
17395 }
17396 {
17397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17398 }
17399 {
17400 if (temp1)
17401 delete arg1;
17402 }
17403 return resultobj;
17404 fail:
17405 {
17406 if (temp1)
17407 delete arg1;
17408 }
17409 return NULL;
17410 }
17411
17412
17413 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17414 PyObject *resultobj = 0;
17415
17416 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17417 {
17418 if (!wxPyCheckForApp()) SWIG_fail;
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 wxSound::Stop();
17421 wxPyEndAllowThreads(__tstate);
17422 if (PyErr_Occurred()) SWIG_fail;
17423 }
17424 resultobj = SWIG_Py_Void();
17425 return resultobj;
17426 fail:
17427 return NULL;
17428 }
17429
17430
17431 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17432 PyObject *obj;
17433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17434 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17435 return SWIG_Py_Void();
17436 }
17437
17438 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17439 return SWIG_Python_InitShadowInstance(args);
17440 }
17441
17442 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj = 0;
17444 wxString *arg1 = 0 ;
17445 wxString *arg2 = 0 ;
17446 wxString *arg3 = 0 ;
17447 wxString *arg4 = 0 ;
17448 wxFileTypeInfo *result = 0 ;
17449 bool temp1 = false ;
17450 bool temp2 = false ;
17451 bool temp3 = false ;
17452 bool temp4 = false ;
17453 PyObject * obj0 = 0 ;
17454 PyObject * obj1 = 0 ;
17455 PyObject * obj2 = 0 ;
17456 PyObject * obj3 = 0 ;
17457 char * kwnames[] = {
17458 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17459 };
17460
17461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17462 {
17463 arg1 = wxString_in_helper(obj0);
17464 if (arg1 == NULL) SWIG_fail;
17465 temp1 = true;
17466 }
17467 {
17468 arg2 = wxString_in_helper(obj1);
17469 if (arg2 == NULL) SWIG_fail;
17470 temp2 = true;
17471 }
17472 {
17473 arg3 = wxString_in_helper(obj2);
17474 if (arg3 == NULL) SWIG_fail;
17475 temp3 = true;
17476 }
17477 {
17478 arg4 = wxString_in_helper(obj3);
17479 if (arg4 == NULL) SWIG_fail;
17480 temp4 = true;
17481 }
17482 {
17483 PyThreadState* __tstate = wxPyBeginAllowThreads();
17484 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17485 wxPyEndAllowThreads(__tstate);
17486 if (PyErr_Occurred()) SWIG_fail;
17487 }
17488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17489 {
17490 if (temp1)
17491 delete arg1;
17492 }
17493 {
17494 if (temp2)
17495 delete arg2;
17496 }
17497 {
17498 if (temp3)
17499 delete arg3;
17500 }
17501 {
17502 if (temp4)
17503 delete arg4;
17504 }
17505 return resultobj;
17506 fail:
17507 {
17508 if (temp1)
17509 delete arg1;
17510 }
17511 {
17512 if (temp2)
17513 delete arg2;
17514 }
17515 {
17516 if (temp3)
17517 delete arg3;
17518 }
17519 {
17520 if (temp4)
17521 delete arg4;
17522 }
17523 return NULL;
17524 }
17525
17526
17527 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj = 0;
17529 wxArrayString *arg1 = 0 ;
17530 wxFileTypeInfo *result = 0 ;
17531 bool temp1 = false ;
17532 PyObject * obj0 = 0 ;
17533 char * kwnames[] = {
17534 (char *) "sArray", NULL
17535 };
17536
17537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17538 {
17539 if (! PySequence_Check(obj0)) {
17540 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17541 SWIG_fail;
17542 }
17543 arg1 = new wxArrayString;
17544 temp1 = true;
17545 int i, len=PySequence_Length(obj0);
17546 for (i=0; i<len; i++) {
17547 PyObject* item = PySequence_GetItem(obj0, i);
17548 wxString* s = wxString_in_helper(item);
17549 if (PyErr_Occurred()) SWIG_fail;
17550 arg1->Add(*s);
17551 delete s;
17552 Py_DECREF(item);
17553 }
17554 }
17555 {
17556 PyThreadState* __tstate = wxPyBeginAllowThreads();
17557 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17558 wxPyEndAllowThreads(__tstate);
17559 if (PyErr_Occurred()) SWIG_fail;
17560 }
17561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17562 {
17563 if (temp1) delete arg1;
17564 }
17565 return resultobj;
17566 fail:
17567 {
17568 if (temp1) delete arg1;
17569 }
17570 return NULL;
17571 }
17572
17573
17574 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17575 PyObject *resultobj = 0;
17576 wxFileTypeInfo *result = 0 ;
17577
17578 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17579 {
17580 PyThreadState* __tstate = wxPyBeginAllowThreads();
17581 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17582 wxPyEndAllowThreads(__tstate);
17583 if (PyErr_Occurred()) SWIG_fail;
17584 }
17585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17586 return resultobj;
17587 fail:
17588 return NULL;
17589 }
17590
17591
17592 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17593 PyObject *resultobj = 0;
17594 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17595 bool result;
17596 void *argp1 = 0 ;
17597 int res1 = 0 ;
17598 PyObject *swig_obj[1] ;
17599
17600 if (!args) SWIG_fail;
17601 swig_obj[0] = args;
17602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17603 if (!SWIG_IsOK(res1)) {
17604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17605 }
17606 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 {
17614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17615 }
17616 return resultobj;
17617 fail:
17618 return NULL;
17619 }
17620
17621
17622 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17623 PyObject *resultobj = 0;
17624 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17625 wxString *arg2 = 0 ;
17626 int arg3 = (int) 0 ;
17627 void *argp1 = 0 ;
17628 int res1 = 0 ;
17629 bool temp2 = false ;
17630 int val3 ;
17631 int ecode3 = 0 ;
17632 PyObject * obj0 = 0 ;
17633 PyObject * obj1 = 0 ;
17634 PyObject * obj2 = 0 ;
17635 char * kwnames[] = {
17636 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17637 };
17638
17639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17641 if (!SWIG_IsOK(res1)) {
17642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17643 }
17644 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17645 {
17646 arg2 = wxString_in_helper(obj1);
17647 if (arg2 == NULL) SWIG_fail;
17648 temp2 = true;
17649 }
17650 if (obj2) {
17651 ecode3 = SWIG_AsVal_int(obj2, &val3);
17652 if (!SWIG_IsOK(ecode3)) {
17653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17654 }
17655 arg3 = static_cast< int >(val3);
17656 }
17657 {
17658 PyThreadState* __tstate = wxPyBeginAllowThreads();
17659 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17660 wxPyEndAllowThreads(__tstate);
17661 if (PyErr_Occurred()) SWIG_fail;
17662 }
17663 resultobj = SWIG_Py_Void();
17664 {
17665 if (temp2)
17666 delete arg2;
17667 }
17668 return resultobj;
17669 fail:
17670 {
17671 if (temp2)
17672 delete arg2;
17673 }
17674 return NULL;
17675 }
17676
17677
17678 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17679 PyObject *resultobj = 0;
17680 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17681 wxString *arg2 = 0 ;
17682 void *argp1 = 0 ;
17683 int res1 = 0 ;
17684 bool temp2 = false ;
17685 PyObject * obj0 = 0 ;
17686 PyObject * obj1 = 0 ;
17687 char * kwnames[] = {
17688 (char *) "self",(char *) "shortDesc", NULL
17689 };
17690
17691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17693 if (!SWIG_IsOK(res1)) {
17694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17695 }
17696 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17697 {
17698 arg2 = wxString_in_helper(obj1);
17699 if (arg2 == NULL) SWIG_fail;
17700 temp2 = true;
17701 }
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 (arg1)->SetShortDesc((wxString const &)*arg2);
17705 wxPyEndAllowThreads(__tstate);
17706 if (PyErr_Occurred()) SWIG_fail;
17707 }
17708 resultobj = SWIG_Py_Void();
17709 {
17710 if (temp2)
17711 delete arg2;
17712 }
17713 return resultobj;
17714 fail:
17715 {
17716 if (temp2)
17717 delete arg2;
17718 }
17719 return NULL;
17720 }
17721
17722
17723 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17724 PyObject *resultobj = 0;
17725 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17726 wxString *result = 0 ;
17727 void *argp1 = 0 ;
17728 int res1 = 0 ;
17729 PyObject *swig_obj[1] ;
17730
17731 if (!args) SWIG_fail;
17732 swig_obj[0] = args;
17733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17734 if (!SWIG_IsOK(res1)) {
17735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17736 }
17737 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17738 {
17739 PyThreadState* __tstate = wxPyBeginAllowThreads();
17740 {
17741 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17742 result = (wxString *) &_result_ref;
17743 }
17744 wxPyEndAllowThreads(__tstate);
17745 if (PyErr_Occurred()) SWIG_fail;
17746 }
17747 {
17748 #if wxUSE_UNICODE
17749 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17750 #else
17751 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17752 #endif
17753 }
17754 return resultobj;
17755 fail:
17756 return NULL;
17757 }
17758
17759
17760 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17761 PyObject *resultobj = 0;
17762 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17763 wxString *result = 0 ;
17764 void *argp1 = 0 ;
17765 int res1 = 0 ;
17766 PyObject *swig_obj[1] ;
17767
17768 if (!args) SWIG_fail;
17769 swig_obj[0] = args;
17770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17771 if (!SWIG_IsOK(res1)) {
17772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17773 }
17774 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17775 {
17776 PyThreadState* __tstate = wxPyBeginAllowThreads();
17777 {
17778 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17779 result = (wxString *) &_result_ref;
17780 }
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 {
17785 #if wxUSE_UNICODE
17786 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17787 #else
17788 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17789 #endif
17790 }
17791 return resultobj;
17792 fail:
17793 return NULL;
17794 }
17795
17796
17797 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17798 PyObject *resultobj = 0;
17799 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17800 wxString *result = 0 ;
17801 void *argp1 = 0 ;
17802 int res1 = 0 ;
17803 PyObject *swig_obj[1] ;
17804
17805 if (!args) SWIG_fail;
17806 swig_obj[0] = args;
17807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17808 if (!SWIG_IsOK(res1)) {
17809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17810 }
17811 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17812 {
17813 PyThreadState* __tstate = wxPyBeginAllowThreads();
17814 {
17815 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17816 result = (wxString *) &_result_ref;
17817 }
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 {
17822 #if wxUSE_UNICODE
17823 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17824 #else
17825 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17826 #endif
17827 }
17828 return resultobj;
17829 fail:
17830 return NULL;
17831 }
17832
17833
17834 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17835 PyObject *resultobj = 0;
17836 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17837 wxString *result = 0 ;
17838 void *argp1 = 0 ;
17839 int res1 = 0 ;
17840 PyObject *swig_obj[1] ;
17841
17842 if (!args) SWIG_fail;
17843 swig_obj[0] = args;
17844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17845 if (!SWIG_IsOK(res1)) {
17846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17847 }
17848 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17849 {
17850 PyThreadState* __tstate = wxPyBeginAllowThreads();
17851 {
17852 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17853 result = (wxString *) &_result_ref;
17854 }
17855 wxPyEndAllowThreads(__tstate);
17856 if (PyErr_Occurred()) SWIG_fail;
17857 }
17858 {
17859 #if wxUSE_UNICODE
17860 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17861 #else
17862 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17863 #endif
17864 }
17865 return resultobj;
17866 fail:
17867 return NULL;
17868 }
17869
17870
17871 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17872 PyObject *resultobj = 0;
17873 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17874 wxString *result = 0 ;
17875 void *argp1 = 0 ;
17876 int res1 = 0 ;
17877 PyObject *swig_obj[1] ;
17878
17879 if (!args) SWIG_fail;
17880 swig_obj[0] = args;
17881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17882 if (!SWIG_IsOK(res1)) {
17883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17884 }
17885 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17886 {
17887 PyThreadState* __tstate = wxPyBeginAllowThreads();
17888 {
17889 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17890 result = (wxString *) &_result_ref;
17891 }
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 {
17896 #if wxUSE_UNICODE
17897 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17898 #else
17899 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17900 #endif
17901 }
17902 return resultobj;
17903 fail:
17904 return NULL;
17905 }
17906
17907
17908 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17909 PyObject *resultobj = 0;
17910 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17911 wxArrayString *result = 0 ;
17912 void *argp1 = 0 ;
17913 int res1 = 0 ;
17914 PyObject *swig_obj[1] ;
17915
17916 if (!args) SWIG_fail;
17917 swig_obj[0] = args;
17918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17919 if (!SWIG_IsOK(res1)) {
17920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17921 }
17922 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17923 {
17924 PyThreadState* __tstate = wxPyBeginAllowThreads();
17925 {
17926 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17927 result = (wxArrayString *) &_result_ref;
17928 }
17929 wxPyEndAllowThreads(__tstate);
17930 if (PyErr_Occurred()) SWIG_fail;
17931 }
17932 {
17933 resultobj = wxArrayString2PyList_helper(*result);
17934 }
17935 return resultobj;
17936 fail:
17937 return NULL;
17938 }
17939
17940
17941 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17942 PyObject *resultobj = 0;
17943 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17944 size_t result;
17945 void *argp1 = 0 ;
17946 int res1 = 0 ;
17947 PyObject *swig_obj[1] ;
17948
17949 if (!args) SWIG_fail;
17950 swig_obj[0] = args;
17951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17952 if (!SWIG_IsOK(res1)) {
17953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17954 }
17955 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17956 {
17957 PyThreadState* __tstate = wxPyBeginAllowThreads();
17958 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17959 wxPyEndAllowThreads(__tstate);
17960 if (PyErr_Occurred()) SWIG_fail;
17961 }
17962 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17963 return resultobj;
17964 fail:
17965 return NULL;
17966 }
17967
17968
17969 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17970 PyObject *resultobj = 0;
17971 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17972 wxString *result = 0 ;
17973 void *argp1 = 0 ;
17974 int res1 = 0 ;
17975 PyObject *swig_obj[1] ;
17976
17977 if (!args) SWIG_fail;
17978 swig_obj[0] = args;
17979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17980 if (!SWIG_IsOK(res1)) {
17981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17982 }
17983 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 {
17987 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17988 result = (wxString *) &_result_ref;
17989 }
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 {
17994 #if wxUSE_UNICODE
17995 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17996 #else
17997 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17998 #endif
17999 }
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18007 PyObject *resultobj = 0;
18008 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18009 int result;
18010 void *argp1 = 0 ;
18011 int res1 = 0 ;
18012 PyObject *swig_obj[1] ;
18013
18014 if (!args) SWIG_fail;
18015 swig_obj[0] = args;
18016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18017 if (!SWIG_IsOK(res1)) {
18018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18019 }
18020 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 resultobj = SWIG_From_int(static_cast< int >(result));
18028 return resultobj;
18029 fail:
18030 return NULL;
18031 }
18032
18033
18034 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18035 PyObject *obj;
18036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18037 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18038 return SWIG_Py_Void();
18039 }
18040
18041 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18042 return SWIG_Python_InitShadowInstance(args);
18043 }
18044
18045 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18046 PyObject *resultobj = 0;
18047 wxFileTypeInfo *arg1 = 0 ;
18048 wxFileType *result = 0 ;
18049 void *argp1 = 0 ;
18050 int res1 = 0 ;
18051 PyObject * obj0 = 0 ;
18052 char * kwnames[] = {
18053 (char *) "ftInfo", NULL
18054 };
18055
18056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18057 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18058 if (!SWIG_IsOK(res1)) {
18059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18060 }
18061 if (!argp1) {
18062 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18063 }
18064 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18065 {
18066 PyThreadState* __tstate = wxPyBeginAllowThreads();
18067 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18068 wxPyEndAllowThreads(__tstate);
18069 if (PyErr_Occurred()) SWIG_fail;
18070 }
18071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18072 return resultobj;
18073 fail:
18074 return NULL;
18075 }
18076
18077
18078 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18079 PyObject *resultobj = 0;
18080 wxFileType *arg1 = (wxFileType *) 0 ;
18081 void *argp1 = 0 ;
18082 int res1 = 0 ;
18083 PyObject *swig_obj[1] ;
18084
18085 if (!args) SWIG_fail;
18086 swig_obj[0] = args;
18087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18088 if (!SWIG_IsOK(res1)) {
18089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18090 }
18091 arg1 = reinterpret_cast< wxFileType * >(argp1);
18092 {
18093 PyThreadState* __tstate = wxPyBeginAllowThreads();
18094 delete arg1;
18095
18096 wxPyEndAllowThreads(__tstate);
18097 if (PyErr_Occurred()) SWIG_fail;
18098 }
18099 resultobj = SWIG_Py_Void();
18100 return resultobj;
18101 fail:
18102 return NULL;
18103 }
18104
18105
18106 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18107 PyObject *resultobj = 0;
18108 wxFileType *arg1 = (wxFileType *) 0 ;
18109 PyObject *result = 0 ;
18110 void *argp1 = 0 ;
18111 int res1 = 0 ;
18112 PyObject *swig_obj[1] ;
18113
18114 if (!args) SWIG_fail;
18115 swig_obj[0] = args;
18116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18117 if (!SWIG_IsOK(res1)) {
18118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18119 }
18120 arg1 = reinterpret_cast< wxFileType * >(argp1);
18121 {
18122 PyThreadState* __tstate = wxPyBeginAllowThreads();
18123 result = (PyObject *)wxFileType_GetMimeType(arg1);
18124 wxPyEndAllowThreads(__tstate);
18125 if (PyErr_Occurred()) SWIG_fail;
18126 }
18127 resultobj = result;
18128 return resultobj;
18129 fail:
18130 return NULL;
18131 }
18132
18133
18134 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18135 PyObject *resultobj = 0;
18136 wxFileType *arg1 = (wxFileType *) 0 ;
18137 PyObject *result = 0 ;
18138 void *argp1 = 0 ;
18139 int res1 = 0 ;
18140 PyObject *swig_obj[1] ;
18141
18142 if (!args) SWIG_fail;
18143 swig_obj[0] = args;
18144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18145 if (!SWIG_IsOK(res1)) {
18146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18147 }
18148 arg1 = reinterpret_cast< wxFileType * >(argp1);
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = result;
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18163 PyObject *resultobj = 0;
18164 wxFileType *arg1 = (wxFileType *) 0 ;
18165 PyObject *result = 0 ;
18166 void *argp1 = 0 ;
18167 int res1 = 0 ;
18168 PyObject *swig_obj[1] ;
18169
18170 if (!args) SWIG_fail;
18171 swig_obj[0] = args;
18172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18173 if (!SWIG_IsOK(res1)) {
18174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18175 }
18176 arg1 = reinterpret_cast< wxFileType * >(argp1);
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (PyObject *)wxFileType_GetExtensions(arg1);
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 resultobj = result;
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18191 PyObject *resultobj = 0;
18192 wxFileType *arg1 = (wxFileType *) 0 ;
18193 wxIcon *result = 0 ;
18194 void *argp1 = 0 ;
18195 int res1 = 0 ;
18196 PyObject *swig_obj[1] ;
18197
18198 if (!args) SWIG_fail;
18199 swig_obj[0] = args;
18200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18201 if (!SWIG_IsOK(res1)) {
18202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18203 }
18204 arg1 = reinterpret_cast< wxFileType * >(argp1);
18205 {
18206 PyThreadState* __tstate = wxPyBeginAllowThreads();
18207 result = (wxIcon *)wxFileType_GetIcon(arg1);
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18212 return resultobj;
18213 fail:
18214 return NULL;
18215 }
18216
18217
18218 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18219 PyObject *resultobj = 0;
18220 wxFileType *arg1 = (wxFileType *) 0 ;
18221 PyObject *result = 0 ;
18222 void *argp1 = 0 ;
18223 int res1 = 0 ;
18224 PyObject *swig_obj[1] ;
18225
18226 if (!args) SWIG_fail;
18227 swig_obj[0] = args;
18228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18229 if (!SWIG_IsOK(res1)) {
18230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18231 }
18232 arg1 = reinterpret_cast< wxFileType * >(argp1);
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18236 wxPyEndAllowThreads(__tstate);
18237 if (PyErr_Occurred()) SWIG_fail;
18238 }
18239 resultobj = result;
18240 return resultobj;
18241 fail:
18242 return NULL;
18243 }
18244
18245
18246 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18247 PyObject *resultobj = 0;
18248 wxFileType *arg1 = (wxFileType *) 0 ;
18249 PyObject *result = 0 ;
18250 void *argp1 = 0 ;
18251 int res1 = 0 ;
18252 PyObject *swig_obj[1] ;
18253
18254 if (!args) SWIG_fail;
18255 swig_obj[0] = args;
18256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18257 if (!SWIG_IsOK(res1)) {
18258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18259 }
18260 arg1 = reinterpret_cast< wxFileType * >(argp1);
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 result = (PyObject *)wxFileType_GetDescription(arg1);
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 resultobj = result;
18268 return resultobj;
18269 fail:
18270 return NULL;
18271 }
18272
18273
18274 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18275 PyObject *resultobj = 0;
18276 wxFileType *arg1 = (wxFileType *) 0 ;
18277 wxString *arg2 = 0 ;
18278 wxString const &arg3_defvalue = wxPyEmptyString ;
18279 wxString *arg3 = (wxString *) &arg3_defvalue ;
18280 PyObject *result = 0 ;
18281 void *argp1 = 0 ;
18282 int res1 = 0 ;
18283 bool temp2 = false ;
18284 bool temp3 = false ;
18285 PyObject * obj0 = 0 ;
18286 PyObject * obj1 = 0 ;
18287 PyObject * obj2 = 0 ;
18288 char * kwnames[] = {
18289 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18290 };
18291
18292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18294 if (!SWIG_IsOK(res1)) {
18295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18296 }
18297 arg1 = reinterpret_cast< wxFileType * >(argp1);
18298 {
18299 arg2 = wxString_in_helper(obj1);
18300 if (arg2 == NULL) SWIG_fail;
18301 temp2 = true;
18302 }
18303 if (obj2) {
18304 {
18305 arg3 = wxString_in_helper(obj2);
18306 if (arg3 == NULL) SWIG_fail;
18307 temp3 = true;
18308 }
18309 }
18310 {
18311 PyThreadState* __tstate = wxPyBeginAllowThreads();
18312 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 resultobj = result;
18317 {
18318 if (temp2)
18319 delete arg2;
18320 }
18321 {
18322 if (temp3)
18323 delete arg3;
18324 }
18325 return resultobj;
18326 fail:
18327 {
18328 if (temp2)
18329 delete arg2;
18330 }
18331 {
18332 if (temp3)
18333 delete arg3;
18334 }
18335 return NULL;
18336 }
18337
18338
18339 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18340 PyObject *resultobj = 0;
18341 wxFileType *arg1 = (wxFileType *) 0 ;
18342 wxString *arg2 = 0 ;
18343 wxString const &arg3_defvalue = wxPyEmptyString ;
18344 wxString *arg3 = (wxString *) &arg3_defvalue ;
18345 PyObject *result = 0 ;
18346 void *argp1 = 0 ;
18347 int res1 = 0 ;
18348 bool temp2 = false ;
18349 bool temp3 = false ;
18350 PyObject * obj0 = 0 ;
18351 PyObject * obj1 = 0 ;
18352 PyObject * obj2 = 0 ;
18353 char * kwnames[] = {
18354 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18355 };
18356
18357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18359 if (!SWIG_IsOK(res1)) {
18360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18361 }
18362 arg1 = reinterpret_cast< wxFileType * >(argp1);
18363 {
18364 arg2 = wxString_in_helper(obj1);
18365 if (arg2 == NULL) SWIG_fail;
18366 temp2 = true;
18367 }
18368 if (obj2) {
18369 {
18370 arg3 = wxString_in_helper(obj2);
18371 if (arg3 == NULL) SWIG_fail;
18372 temp3 = true;
18373 }
18374 }
18375 {
18376 PyThreadState* __tstate = wxPyBeginAllowThreads();
18377 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 resultobj = result;
18382 {
18383 if (temp2)
18384 delete arg2;
18385 }
18386 {
18387 if (temp3)
18388 delete arg3;
18389 }
18390 return resultobj;
18391 fail:
18392 {
18393 if (temp2)
18394 delete arg2;
18395 }
18396 {
18397 if (temp3)
18398 delete arg3;
18399 }
18400 return NULL;
18401 }
18402
18403
18404 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18405 PyObject *resultobj = 0;
18406 wxFileType *arg1 = (wxFileType *) 0 ;
18407 wxString *arg2 = 0 ;
18408 wxString const &arg3_defvalue = wxPyEmptyString ;
18409 wxString *arg3 = (wxString *) &arg3_defvalue ;
18410 PyObject *result = 0 ;
18411 void *argp1 = 0 ;
18412 int res1 = 0 ;
18413 bool temp2 = false ;
18414 bool temp3 = false ;
18415 PyObject * obj0 = 0 ;
18416 PyObject * obj1 = 0 ;
18417 PyObject * obj2 = 0 ;
18418 char * kwnames[] = {
18419 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18420 };
18421
18422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18424 if (!SWIG_IsOK(res1)) {
18425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18426 }
18427 arg1 = reinterpret_cast< wxFileType * >(argp1);
18428 {
18429 arg2 = wxString_in_helper(obj1);
18430 if (arg2 == NULL) SWIG_fail;
18431 temp2 = true;
18432 }
18433 if (obj2) {
18434 {
18435 arg3 = wxString_in_helper(obj2);
18436 if (arg3 == NULL) SWIG_fail;
18437 temp3 = true;
18438 }
18439 }
18440 {
18441 PyThreadState* __tstate = wxPyBeginAllowThreads();
18442 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18443 wxPyEndAllowThreads(__tstate);
18444 if (PyErr_Occurred()) SWIG_fail;
18445 }
18446 resultobj = result;
18447 {
18448 if (temp2)
18449 delete arg2;
18450 }
18451 {
18452 if (temp3)
18453 delete arg3;
18454 }
18455 return resultobj;
18456 fail:
18457 {
18458 if (temp2)
18459 delete arg2;
18460 }
18461 {
18462 if (temp3)
18463 delete arg3;
18464 }
18465 return NULL;
18466 }
18467
18468
18469 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18470 PyObject *resultobj = 0;
18471 wxFileType *arg1 = (wxFileType *) 0 ;
18472 wxString *arg2 = 0 ;
18473 wxString *arg3 = 0 ;
18474 bool arg4 = (bool) true ;
18475 bool result;
18476 void *argp1 = 0 ;
18477 int res1 = 0 ;
18478 bool temp2 = false ;
18479 bool temp3 = false ;
18480 bool val4 ;
18481 int ecode4 = 0 ;
18482 PyObject * obj0 = 0 ;
18483 PyObject * obj1 = 0 ;
18484 PyObject * obj2 = 0 ;
18485 PyObject * obj3 = 0 ;
18486 char * kwnames[] = {
18487 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18488 };
18489
18490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18492 if (!SWIG_IsOK(res1)) {
18493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18494 }
18495 arg1 = reinterpret_cast< wxFileType * >(argp1);
18496 {
18497 arg2 = wxString_in_helper(obj1);
18498 if (arg2 == NULL) SWIG_fail;
18499 temp2 = true;
18500 }
18501 {
18502 arg3 = wxString_in_helper(obj2);
18503 if (arg3 == NULL) SWIG_fail;
18504 temp3 = true;
18505 }
18506 if (obj3) {
18507 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18508 if (!SWIG_IsOK(ecode4)) {
18509 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18510 }
18511 arg4 = static_cast< bool >(val4);
18512 }
18513 {
18514 PyThreadState* __tstate = wxPyBeginAllowThreads();
18515 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18516 wxPyEndAllowThreads(__tstate);
18517 if (PyErr_Occurred()) SWIG_fail;
18518 }
18519 {
18520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18521 }
18522 {
18523 if (temp2)
18524 delete arg2;
18525 }
18526 {
18527 if (temp3)
18528 delete arg3;
18529 }
18530 return resultobj;
18531 fail:
18532 {
18533 if (temp2)
18534 delete arg2;
18535 }
18536 {
18537 if (temp3)
18538 delete arg3;
18539 }
18540 return NULL;
18541 }
18542
18543
18544 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18545 PyObject *resultobj = 0;
18546 wxFileType *arg1 = (wxFileType *) 0 ;
18547 wxString const &arg2_defvalue = wxPyEmptyString ;
18548 wxString *arg2 = (wxString *) &arg2_defvalue ;
18549 int arg3 = (int) 0 ;
18550 bool result;
18551 void *argp1 = 0 ;
18552 int res1 = 0 ;
18553 bool temp2 = false ;
18554 int val3 ;
18555 int ecode3 = 0 ;
18556 PyObject * obj0 = 0 ;
18557 PyObject * obj1 = 0 ;
18558 PyObject * obj2 = 0 ;
18559 char * kwnames[] = {
18560 (char *) "self",(char *) "cmd",(char *) "index", NULL
18561 };
18562
18563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18565 if (!SWIG_IsOK(res1)) {
18566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18567 }
18568 arg1 = reinterpret_cast< wxFileType * >(argp1);
18569 if (obj1) {
18570 {
18571 arg2 = wxString_in_helper(obj1);
18572 if (arg2 == NULL) SWIG_fail;
18573 temp2 = true;
18574 }
18575 }
18576 if (obj2) {
18577 ecode3 = SWIG_AsVal_int(obj2, &val3);
18578 if (!SWIG_IsOK(ecode3)) {
18579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18580 }
18581 arg3 = static_cast< int >(val3);
18582 }
18583 {
18584 PyThreadState* __tstate = wxPyBeginAllowThreads();
18585 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18586 wxPyEndAllowThreads(__tstate);
18587 if (PyErr_Occurred()) SWIG_fail;
18588 }
18589 {
18590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18591 }
18592 {
18593 if (temp2)
18594 delete arg2;
18595 }
18596 return resultobj;
18597 fail:
18598 {
18599 if (temp2)
18600 delete arg2;
18601 }
18602 return NULL;
18603 }
18604
18605
18606 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18607 PyObject *resultobj = 0;
18608 wxFileType *arg1 = (wxFileType *) 0 ;
18609 bool result;
18610 void *argp1 = 0 ;
18611 int res1 = 0 ;
18612 PyObject *swig_obj[1] ;
18613
18614 if (!args) SWIG_fail;
18615 swig_obj[0] = args;
18616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18617 if (!SWIG_IsOK(res1)) {
18618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18619 }
18620 arg1 = reinterpret_cast< wxFileType * >(argp1);
18621 {
18622 PyThreadState* __tstate = wxPyBeginAllowThreads();
18623 result = (bool)(arg1)->Unassociate();
18624 wxPyEndAllowThreads(__tstate);
18625 if (PyErr_Occurred()) SWIG_fail;
18626 }
18627 {
18628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18629 }
18630 return resultobj;
18631 fail:
18632 return NULL;
18633 }
18634
18635
18636 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18637 PyObject *resultobj = 0;
18638 wxString *arg1 = 0 ;
18639 wxString *arg2 = 0 ;
18640 wxString const &arg3_defvalue = wxPyEmptyString ;
18641 wxString *arg3 = (wxString *) &arg3_defvalue ;
18642 wxString result;
18643 bool temp1 = false ;
18644 bool temp2 = false ;
18645 bool temp3 = false ;
18646 PyObject * obj0 = 0 ;
18647 PyObject * obj1 = 0 ;
18648 PyObject * obj2 = 0 ;
18649 char * kwnames[] = {
18650 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18651 };
18652
18653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18654 {
18655 arg1 = wxString_in_helper(obj0);
18656 if (arg1 == NULL) SWIG_fail;
18657 temp1 = true;
18658 }
18659 {
18660 arg2 = wxString_in_helper(obj1);
18661 if (arg2 == NULL) SWIG_fail;
18662 temp2 = true;
18663 }
18664 if (obj2) {
18665 {
18666 arg3 = wxString_in_helper(obj2);
18667 if (arg3 == NULL) SWIG_fail;
18668 temp3 = true;
18669 }
18670 }
18671 {
18672 PyThreadState* __tstate = wxPyBeginAllowThreads();
18673 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18674 wxPyEndAllowThreads(__tstate);
18675 if (PyErr_Occurred()) SWIG_fail;
18676 }
18677 {
18678 #if wxUSE_UNICODE
18679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18680 #else
18681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18682 #endif
18683 }
18684 {
18685 if (temp1)
18686 delete arg1;
18687 }
18688 {
18689 if (temp2)
18690 delete arg2;
18691 }
18692 {
18693 if (temp3)
18694 delete arg3;
18695 }
18696 return resultobj;
18697 fail:
18698 {
18699 if (temp1)
18700 delete arg1;
18701 }
18702 {
18703 if (temp2)
18704 delete arg2;
18705 }
18706 {
18707 if (temp3)
18708 delete arg3;
18709 }
18710 return NULL;
18711 }
18712
18713
18714 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18715 PyObject *obj;
18716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18717 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18718 return SWIG_Py_Void();
18719 }
18720
18721 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18722 return SWIG_Python_InitShadowInstance(args);
18723 }
18724
18725 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18726 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18727 return 1;
18728 }
18729
18730
18731 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18732 PyObject *pyobj = 0;
18733
18734 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18735 return pyobj;
18736 }
18737
18738
18739 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18740 PyObject *resultobj = 0;
18741 wxString *arg1 = 0 ;
18742 wxString *arg2 = 0 ;
18743 bool result;
18744 bool temp1 = false ;
18745 bool temp2 = false ;
18746 PyObject * obj0 = 0 ;
18747 PyObject * obj1 = 0 ;
18748 char * kwnames[] = {
18749 (char *) "mimeType",(char *) "wildcard", NULL
18750 };
18751
18752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18753 {
18754 arg1 = wxString_in_helper(obj0);
18755 if (arg1 == NULL) SWIG_fail;
18756 temp1 = true;
18757 }
18758 {
18759 arg2 = wxString_in_helper(obj1);
18760 if (arg2 == NULL) SWIG_fail;
18761 temp2 = true;
18762 }
18763 {
18764 PyThreadState* __tstate = wxPyBeginAllowThreads();
18765 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18766 wxPyEndAllowThreads(__tstate);
18767 if (PyErr_Occurred()) SWIG_fail;
18768 }
18769 {
18770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18771 }
18772 {
18773 if (temp1)
18774 delete arg1;
18775 }
18776 {
18777 if (temp2)
18778 delete arg2;
18779 }
18780 return resultobj;
18781 fail:
18782 {
18783 if (temp1)
18784 delete arg1;
18785 }
18786 {
18787 if (temp2)
18788 delete arg2;
18789 }
18790 return NULL;
18791 }
18792
18793
18794 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18795 PyObject *resultobj = 0;
18796 wxMimeTypesManager *result = 0 ;
18797
18798 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18799 {
18800 PyThreadState* __tstate = wxPyBeginAllowThreads();
18801 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18802 wxPyEndAllowThreads(__tstate);
18803 if (PyErr_Occurred()) SWIG_fail;
18804 }
18805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18806 return resultobj;
18807 fail:
18808 return NULL;
18809 }
18810
18811
18812 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18813 PyObject *resultobj = 0;
18814 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18815 int arg2 = (int) wxMAILCAP_ALL ;
18816 wxString const &arg3_defvalue = wxPyEmptyString ;
18817 wxString *arg3 = (wxString *) &arg3_defvalue ;
18818 void *argp1 = 0 ;
18819 int res1 = 0 ;
18820 int val2 ;
18821 int ecode2 = 0 ;
18822 bool temp3 = false ;
18823 PyObject * obj0 = 0 ;
18824 PyObject * obj1 = 0 ;
18825 PyObject * obj2 = 0 ;
18826 char * kwnames[] = {
18827 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18828 };
18829
18830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18832 if (!SWIG_IsOK(res1)) {
18833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18834 }
18835 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18836 if (obj1) {
18837 ecode2 = SWIG_AsVal_int(obj1, &val2);
18838 if (!SWIG_IsOK(ecode2)) {
18839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18840 }
18841 arg2 = static_cast< int >(val2);
18842 }
18843 if (obj2) {
18844 {
18845 arg3 = wxString_in_helper(obj2);
18846 if (arg3 == NULL) SWIG_fail;
18847 temp3 = true;
18848 }
18849 }
18850 {
18851 PyThreadState* __tstate = wxPyBeginAllowThreads();
18852 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18853 wxPyEndAllowThreads(__tstate);
18854 if (PyErr_Occurred()) SWIG_fail;
18855 }
18856 resultobj = SWIG_Py_Void();
18857 {
18858 if (temp3)
18859 delete arg3;
18860 }
18861 return resultobj;
18862 fail:
18863 {
18864 if (temp3)
18865 delete arg3;
18866 }
18867 return NULL;
18868 }
18869
18870
18871 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18872 PyObject *resultobj = 0;
18873 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18874 void *argp1 = 0 ;
18875 int res1 = 0 ;
18876 PyObject *swig_obj[1] ;
18877
18878 if (!args) SWIG_fail;
18879 swig_obj[0] = args;
18880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18881 if (!SWIG_IsOK(res1)) {
18882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18883 }
18884 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18885 {
18886 PyThreadState* __tstate = wxPyBeginAllowThreads();
18887 (arg1)->ClearData();
18888 wxPyEndAllowThreads(__tstate);
18889 if (PyErr_Occurred()) SWIG_fail;
18890 }
18891 resultobj = SWIG_Py_Void();
18892 return resultobj;
18893 fail:
18894 return NULL;
18895 }
18896
18897
18898 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18899 PyObject *resultobj = 0;
18900 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18901 wxString *arg2 = 0 ;
18902 wxFileType *result = 0 ;
18903 void *argp1 = 0 ;
18904 int res1 = 0 ;
18905 bool temp2 = false ;
18906 PyObject * obj0 = 0 ;
18907 PyObject * obj1 = 0 ;
18908 char * kwnames[] = {
18909 (char *) "self",(char *) "ext", NULL
18910 };
18911
18912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18914 if (!SWIG_IsOK(res1)) {
18915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18916 }
18917 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18918 {
18919 arg2 = wxString_in_helper(obj1);
18920 if (arg2 == NULL) SWIG_fail;
18921 temp2 = true;
18922 }
18923 {
18924 PyThreadState* __tstate = wxPyBeginAllowThreads();
18925 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18930 {
18931 if (temp2)
18932 delete arg2;
18933 }
18934 return resultobj;
18935 fail:
18936 {
18937 if (temp2)
18938 delete arg2;
18939 }
18940 return NULL;
18941 }
18942
18943
18944 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18945 PyObject *resultobj = 0;
18946 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18947 wxString *arg2 = 0 ;
18948 wxFileType *result = 0 ;
18949 void *argp1 = 0 ;
18950 int res1 = 0 ;
18951 bool temp2 = false ;
18952 PyObject * obj0 = 0 ;
18953 PyObject * obj1 = 0 ;
18954 char * kwnames[] = {
18955 (char *) "self",(char *) "mimeType", NULL
18956 };
18957
18958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18960 if (!SWIG_IsOK(res1)) {
18961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18962 }
18963 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18964 {
18965 arg2 = wxString_in_helper(obj1);
18966 if (arg2 == NULL) SWIG_fail;
18967 temp2 = true;
18968 }
18969 {
18970 PyThreadState* __tstate = wxPyBeginAllowThreads();
18971 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18972 wxPyEndAllowThreads(__tstate);
18973 if (PyErr_Occurred()) SWIG_fail;
18974 }
18975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18976 {
18977 if (temp2)
18978 delete arg2;
18979 }
18980 return resultobj;
18981 fail:
18982 {
18983 if (temp2)
18984 delete arg2;
18985 }
18986 return NULL;
18987 }
18988
18989
18990 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18991 PyObject *resultobj = 0;
18992 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18993 wxString *arg2 = 0 ;
18994 bool arg3 = (bool) false ;
18995 bool result;
18996 void *argp1 = 0 ;
18997 int res1 = 0 ;
18998 bool temp2 = false ;
18999 bool val3 ;
19000 int ecode3 = 0 ;
19001 PyObject * obj0 = 0 ;
19002 PyObject * obj1 = 0 ;
19003 PyObject * obj2 = 0 ;
19004 char * kwnames[] = {
19005 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19006 };
19007
19008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19010 if (!SWIG_IsOK(res1)) {
19011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19012 }
19013 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19014 {
19015 arg2 = wxString_in_helper(obj1);
19016 if (arg2 == NULL) SWIG_fail;
19017 temp2 = true;
19018 }
19019 if (obj2) {
19020 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19021 if (!SWIG_IsOK(ecode3)) {
19022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19023 }
19024 arg3 = static_cast< bool >(val3);
19025 }
19026 {
19027 PyThreadState* __tstate = wxPyBeginAllowThreads();
19028 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19029 wxPyEndAllowThreads(__tstate);
19030 if (PyErr_Occurred()) SWIG_fail;
19031 }
19032 {
19033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19034 }
19035 {
19036 if (temp2)
19037 delete arg2;
19038 }
19039 return resultobj;
19040 fail:
19041 {
19042 if (temp2)
19043 delete arg2;
19044 }
19045 return NULL;
19046 }
19047
19048
19049 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19050 PyObject *resultobj = 0;
19051 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19052 wxString *arg2 = 0 ;
19053 bool result;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 bool temp2 = false ;
19057 PyObject * obj0 = 0 ;
19058 PyObject * obj1 = 0 ;
19059 char * kwnames[] = {
19060 (char *) "self",(char *) "filename", NULL
19061 };
19062
19063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19065 if (!SWIG_IsOK(res1)) {
19066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19067 }
19068 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19069 {
19070 arg2 = wxString_in_helper(obj1);
19071 if (arg2 == NULL) SWIG_fail;
19072 temp2 = true;
19073 }
19074 {
19075 PyThreadState* __tstate = wxPyBeginAllowThreads();
19076 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19077 wxPyEndAllowThreads(__tstate);
19078 if (PyErr_Occurred()) SWIG_fail;
19079 }
19080 {
19081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19082 }
19083 {
19084 if (temp2)
19085 delete arg2;
19086 }
19087 return resultobj;
19088 fail:
19089 {
19090 if (temp2)
19091 delete arg2;
19092 }
19093 return NULL;
19094 }
19095
19096
19097 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19098 PyObject *resultobj = 0;
19099 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19100 PyObject *result = 0 ;
19101 void *argp1 = 0 ;
19102 int res1 = 0 ;
19103 PyObject *swig_obj[1] ;
19104
19105 if (!args) SWIG_fail;
19106 swig_obj[0] = args;
19107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19108 if (!SWIG_IsOK(res1)) {
19109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19110 }
19111 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19112 {
19113 PyThreadState* __tstate = wxPyBeginAllowThreads();
19114 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19115 wxPyEndAllowThreads(__tstate);
19116 if (PyErr_Occurred()) SWIG_fail;
19117 }
19118 resultobj = result;
19119 return resultobj;
19120 fail:
19121 return NULL;
19122 }
19123
19124
19125 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19126 PyObject *resultobj = 0;
19127 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19128 wxFileTypeInfo *arg2 = 0 ;
19129 void *argp1 = 0 ;
19130 int res1 = 0 ;
19131 void *argp2 = 0 ;
19132 int res2 = 0 ;
19133 PyObject * obj0 = 0 ;
19134 PyObject * obj1 = 0 ;
19135 char * kwnames[] = {
19136 (char *) "self",(char *) "ft", NULL
19137 };
19138
19139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19141 if (!SWIG_IsOK(res1)) {
19142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19143 }
19144 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19145 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19146 if (!SWIG_IsOK(res2)) {
19147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19148 }
19149 if (!argp2) {
19150 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19151 }
19152 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19156 wxPyEndAllowThreads(__tstate);
19157 if (PyErr_Occurred()) SWIG_fail;
19158 }
19159 resultobj = SWIG_Py_Void();
19160 return resultobj;
19161 fail:
19162 return NULL;
19163 }
19164
19165
19166 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19167 PyObject *resultobj = 0;
19168 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19169 wxFileTypeInfo *arg2 = 0 ;
19170 wxFileType *result = 0 ;
19171 void *argp1 = 0 ;
19172 int res1 = 0 ;
19173 void *argp2 = 0 ;
19174 int res2 = 0 ;
19175 PyObject * obj0 = 0 ;
19176 PyObject * obj1 = 0 ;
19177 char * kwnames[] = {
19178 (char *) "self",(char *) "ftInfo", NULL
19179 };
19180
19181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19183 if (!SWIG_IsOK(res1)) {
19184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19185 }
19186 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19187 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19188 if (!SWIG_IsOK(res2)) {
19189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19190 }
19191 if (!argp2) {
19192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19193 }
19194 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj = 0;
19210 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19211 wxFileType *arg2 = (wxFileType *) 0 ;
19212 bool result;
19213 void *argp1 = 0 ;
19214 int res1 = 0 ;
19215 void *argp2 = 0 ;
19216 int res2 = 0 ;
19217 PyObject * obj0 = 0 ;
19218 PyObject * obj1 = 0 ;
19219 char * kwnames[] = {
19220 (char *) "self",(char *) "ft", NULL
19221 };
19222
19223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19225 if (!SWIG_IsOK(res1)) {
19226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19227 }
19228 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19230 if (!SWIG_IsOK(res2)) {
19231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19232 }
19233 arg2 = reinterpret_cast< wxFileType * >(argp2);
19234 {
19235 PyThreadState* __tstate = wxPyBeginAllowThreads();
19236 result = (bool)(arg1)->Unassociate(arg2);
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 {
19241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19242 }
19243 return resultobj;
19244 fail:
19245 return NULL;
19246 }
19247
19248
19249 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19250 PyObject *resultobj = 0;
19251 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19252 void *argp1 = 0 ;
19253 int res1 = 0 ;
19254 PyObject *swig_obj[1] ;
19255
19256 if (!args) SWIG_fail;
19257 swig_obj[0] = args;
19258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19259 if (!SWIG_IsOK(res1)) {
19260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19261 }
19262 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19263 {
19264 PyThreadState* __tstate = wxPyBeginAllowThreads();
19265 delete arg1;
19266
19267 wxPyEndAllowThreads(__tstate);
19268 if (PyErr_Occurred()) SWIG_fail;
19269 }
19270 resultobj = SWIG_Py_Void();
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19278 PyObject *obj;
19279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19280 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19281 return SWIG_Py_Void();
19282 }
19283
19284 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19285 return SWIG_Python_InitShadowInstance(args);
19286 }
19287
19288 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19289 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19290 return 1;
19291 }
19292
19293
19294 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19295 PyObject *pyobj = 0;
19296
19297 {
19298 #if wxUSE_UNICODE
19299 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19300 #else
19301 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19302 #endif
19303 }
19304 return pyobj;
19305 }
19306
19307
19308 SWIGINTERN int ART_MENU_set(PyObject *) {
19309 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19310 return 1;
19311 }
19312
19313
19314 SWIGINTERN PyObject *ART_MENU_get(void) {
19315 PyObject *pyobj = 0;
19316
19317 {
19318 #if wxUSE_UNICODE
19319 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19320 #else
19321 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19322 #endif
19323 }
19324 return pyobj;
19325 }
19326
19327
19328 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19329 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19330 return 1;
19331 }
19332
19333
19334 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19335 PyObject *pyobj = 0;
19336
19337 {
19338 #if wxUSE_UNICODE
19339 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19340 #else
19341 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19342 #endif
19343 }
19344 return pyobj;
19345 }
19346
19347
19348 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19349 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19350 return 1;
19351 }
19352
19353
19354 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19355 PyObject *pyobj = 0;
19356
19357 {
19358 #if wxUSE_UNICODE
19359 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19360 #else
19361 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19362 #endif
19363 }
19364 return pyobj;
19365 }
19366
19367
19368 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19369 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19370 return 1;
19371 }
19372
19373
19374 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19375 PyObject *pyobj = 0;
19376
19377 {
19378 #if wxUSE_UNICODE
19379 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19380 #else
19381 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19382 #endif
19383 }
19384 return pyobj;
19385 }
19386
19387
19388 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19389 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19390 return 1;
19391 }
19392
19393
19394 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19395 PyObject *pyobj = 0;
19396
19397 {
19398 #if wxUSE_UNICODE
19399 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19400 #else
19401 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19402 #endif
19403 }
19404 return pyobj;
19405 }
19406
19407
19408 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19409 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19410 return 1;
19411 }
19412
19413
19414 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19415 PyObject *pyobj = 0;
19416
19417 {
19418 #if wxUSE_UNICODE
19419 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19420 #else
19421 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19422 #endif
19423 }
19424 return pyobj;
19425 }
19426
19427
19428 SWIGINTERN int ART_OTHER_set(PyObject *) {
19429 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19430 return 1;
19431 }
19432
19433
19434 SWIGINTERN PyObject *ART_OTHER_get(void) {
19435 PyObject *pyobj = 0;
19436
19437 {
19438 #if wxUSE_UNICODE
19439 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19440 #else
19441 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19442 #endif
19443 }
19444 return pyobj;
19445 }
19446
19447
19448 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19449 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19450 return 1;
19451 }
19452
19453
19454 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19455 PyObject *pyobj = 0;
19456
19457 {
19458 #if wxUSE_UNICODE
19459 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19460 #else
19461 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19462 #endif
19463 }
19464 return pyobj;
19465 }
19466
19467
19468 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19469 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19470 return 1;
19471 }
19472
19473
19474 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19475 PyObject *pyobj = 0;
19476
19477 {
19478 #if wxUSE_UNICODE
19479 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19480 #else
19481 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19482 #endif
19483 }
19484 return pyobj;
19485 }
19486
19487
19488 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19489 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19490 return 1;
19491 }
19492
19493
19494 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19495 PyObject *pyobj = 0;
19496
19497 {
19498 #if wxUSE_UNICODE
19499 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19500 #else
19501 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19502 #endif
19503 }
19504 return pyobj;
19505 }
19506
19507
19508 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19509 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19510 return 1;
19511 }
19512
19513
19514 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19515 PyObject *pyobj = 0;
19516
19517 {
19518 #if wxUSE_UNICODE
19519 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19520 #else
19521 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19522 #endif
19523 }
19524 return pyobj;
19525 }
19526
19527
19528 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19529 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19530 return 1;
19531 }
19532
19533
19534 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19535 PyObject *pyobj = 0;
19536
19537 {
19538 #if wxUSE_UNICODE
19539 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19540 #else
19541 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19542 #endif
19543 }
19544 return pyobj;
19545 }
19546
19547
19548 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19549 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19550 return 1;
19551 }
19552
19553
19554 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19555 PyObject *pyobj = 0;
19556
19557 {
19558 #if wxUSE_UNICODE
19559 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19560 #else
19561 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19562 #endif
19563 }
19564 return pyobj;
19565 }
19566
19567
19568 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19569 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19570 return 1;
19571 }
19572
19573
19574 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19575 PyObject *pyobj = 0;
19576
19577 {
19578 #if wxUSE_UNICODE
19579 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19580 #else
19581 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19582 #endif
19583 }
19584 return pyobj;
19585 }
19586
19587
19588 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19589 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19590 return 1;
19591 }
19592
19593
19594 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19595 PyObject *pyobj = 0;
19596
19597 {
19598 #if wxUSE_UNICODE
19599 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19600 #else
19601 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19602 #endif
19603 }
19604 return pyobj;
19605 }
19606
19607
19608 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19609 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19610 return 1;
19611 }
19612
19613
19614 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19615 PyObject *pyobj = 0;
19616
19617 {
19618 #if wxUSE_UNICODE
19619 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19620 #else
19621 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19622 #endif
19623 }
19624 return pyobj;
19625 }
19626
19627
19628 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19629 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19630 return 1;
19631 }
19632
19633
19634 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19635 PyObject *pyobj = 0;
19636
19637 {
19638 #if wxUSE_UNICODE
19639 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19640 #else
19641 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19642 #endif
19643 }
19644 return pyobj;
19645 }
19646
19647
19648 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19649 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19650 return 1;
19651 }
19652
19653
19654 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19655 PyObject *pyobj = 0;
19656
19657 {
19658 #if wxUSE_UNICODE
19659 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19660 #else
19661 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19662 #endif
19663 }
19664 return pyobj;
19665 }
19666
19667
19668 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19669 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19670 return 1;
19671 }
19672
19673
19674 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19675 PyObject *pyobj = 0;
19676
19677 {
19678 #if wxUSE_UNICODE
19679 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19680 #else
19681 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19682 #endif
19683 }
19684 return pyobj;
19685 }
19686
19687
19688 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19689 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19690 return 1;
19691 }
19692
19693
19694 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19695 PyObject *pyobj = 0;
19696
19697 {
19698 #if wxUSE_UNICODE
19699 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19700 #else
19701 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19702 #endif
19703 }
19704 return pyobj;
19705 }
19706
19707
19708 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19709 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19710 return 1;
19711 }
19712
19713
19714 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19715 PyObject *pyobj = 0;
19716
19717 {
19718 #if wxUSE_UNICODE
19719 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19720 #else
19721 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19722 #endif
19723 }
19724 return pyobj;
19725 }
19726
19727
19728 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19729 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19730 return 1;
19731 }
19732
19733
19734 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19735 PyObject *pyobj = 0;
19736
19737 {
19738 #if wxUSE_UNICODE
19739 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19740 #else
19741 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19742 #endif
19743 }
19744 return pyobj;
19745 }
19746
19747
19748 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19749 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19750 return 1;
19751 }
19752
19753
19754 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19755 PyObject *pyobj = 0;
19756
19757 {
19758 #if wxUSE_UNICODE
19759 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19760 #else
19761 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19762 #endif
19763 }
19764 return pyobj;
19765 }
19766
19767
19768 SWIGINTERN int ART_PRINT_set(PyObject *) {
19769 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19770 return 1;
19771 }
19772
19773
19774 SWIGINTERN PyObject *ART_PRINT_get(void) {
19775 PyObject *pyobj = 0;
19776
19777 {
19778 #if wxUSE_UNICODE
19779 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19780 #else
19781 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19782 #endif
19783 }
19784 return pyobj;
19785 }
19786
19787
19788 SWIGINTERN int ART_HELP_set(PyObject *) {
19789 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19790 return 1;
19791 }
19792
19793
19794 SWIGINTERN PyObject *ART_HELP_get(void) {
19795 PyObject *pyobj = 0;
19796
19797 {
19798 #if wxUSE_UNICODE
19799 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19800 #else
19801 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19802 #endif
19803 }
19804 return pyobj;
19805 }
19806
19807
19808 SWIGINTERN int ART_TIP_set(PyObject *) {
19809 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19810 return 1;
19811 }
19812
19813
19814 SWIGINTERN PyObject *ART_TIP_get(void) {
19815 PyObject *pyobj = 0;
19816
19817 {
19818 #if wxUSE_UNICODE
19819 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19820 #else
19821 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19822 #endif
19823 }
19824 return pyobj;
19825 }
19826
19827
19828 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19829 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19830 return 1;
19831 }
19832
19833
19834 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19835 PyObject *pyobj = 0;
19836
19837 {
19838 #if wxUSE_UNICODE
19839 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19840 #else
19841 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19842 #endif
19843 }
19844 return pyobj;
19845 }
19846
19847
19848 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19849 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19850 return 1;
19851 }
19852
19853
19854 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19855 PyObject *pyobj = 0;
19856
19857 {
19858 #if wxUSE_UNICODE
19859 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19860 #else
19861 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19862 #endif
19863 }
19864 return pyobj;
19865 }
19866
19867
19868 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19869 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19870 return 1;
19871 }
19872
19873
19874 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19875 PyObject *pyobj = 0;
19876
19877 {
19878 #if wxUSE_UNICODE
19879 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19880 #else
19881 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19882 #endif
19883 }
19884 return pyobj;
19885 }
19886
19887
19888 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19889 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19890 return 1;
19891 }
19892
19893
19894 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19895 PyObject *pyobj = 0;
19896
19897 {
19898 #if wxUSE_UNICODE
19899 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19900 #else
19901 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19902 #endif
19903 }
19904 return pyobj;
19905 }
19906
19907
19908 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19909 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19910 return 1;
19911 }
19912
19913
19914 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19915 PyObject *pyobj = 0;
19916
19917 {
19918 #if wxUSE_UNICODE
19919 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19920 #else
19921 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19922 #endif
19923 }
19924 return pyobj;
19925 }
19926
19927
19928 SWIGINTERN int ART_CDROM_set(PyObject *) {
19929 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19930 return 1;
19931 }
19932
19933
19934 SWIGINTERN PyObject *ART_CDROM_get(void) {
19935 PyObject *pyobj = 0;
19936
19937 {
19938 #if wxUSE_UNICODE
19939 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19940 #else
19941 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19942 #endif
19943 }
19944 return pyobj;
19945 }
19946
19947
19948 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19949 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19950 return 1;
19951 }
19952
19953
19954 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19955 PyObject *pyobj = 0;
19956
19957 {
19958 #if wxUSE_UNICODE
19959 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19960 #else
19961 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19962 #endif
19963 }
19964 return pyobj;
19965 }
19966
19967
19968 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19969 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19970 return 1;
19971 }
19972
19973
19974 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19975 PyObject *pyobj = 0;
19976
19977 {
19978 #if wxUSE_UNICODE
19979 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19980 #else
19981 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19982 #endif
19983 }
19984 return pyobj;
19985 }
19986
19987
19988 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19989 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19990 return 1;
19991 }
19992
19993
19994 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19995 PyObject *pyobj = 0;
19996
19997 {
19998 #if wxUSE_UNICODE
19999 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20000 #else
20001 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20002 #endif
20003 }
20004 return pyobj;
20005 }
20006
20007
20008 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20009 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20010 return 1;
20011 }
20012
20013
20014 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20015 PyObject *pyobj = 0;
20016
20017 {
20018 #if wxUSE_UNICODE
20019 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20020 #else
20021 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20022 #endif
20023 }
20024 return pyobj;
20025 }
20026
20027
20028 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20029 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20030 return 1;
20031 }
20032
20033
20034 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20035 PyObject *pyobj = 0;
20036
20037 {
20038 #if wxUSE_UNICODE
20039 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20040 #else
20041 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20042 #endif
20043 }
20044 return pyobj;
20045 }
20046
20047
20048 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20049 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20050 return 1;
20051 }
20052
20053
20054 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20055 PyObject *pyobj = 0;
20056
20057 {
20058 #if wxUSE_UNICODE
20059 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20060 #else
20061 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20062 #endif
20063 }
20064 return pyobj;
20065 }
20066
20067
20068 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20069 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20070 return 1;
20071 }
20072
20073
20074 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20075 PyObject *pyobj = 0;
20076
20077 {
20078 #if wxUSE_UNICODE
20079 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20080 #else
20081 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20082 #endif
20083 }
20084 return pyobj;
20085 }
20086
20087
20088 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20089 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20090 return 1;
20091 }
20092
20093
20094 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20095 PyObject *pyobj = 0;
20096
20097 {
20098 #if wxUSE_UNICODE
20099 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20100 #else
20101 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20102 #endif
20103 }
20104 return pyobj;
20105 }
20106
20107
20108 SWIGINTERN int ART_ERROR_set(PyObject *) {
20109 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20110 return 1;
20111 }
20112
20113
20114 SWIGINTERN PyObject *ART_ERROR_get(void) {
20115 PyObject *pyobj = 0;
20116
20117 {
20118 #if wxUSE_UNICODE
20119 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20120 #else
20121 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20122 #endif
20123 }
20124 return pyobj;
20125 }
20126
20127
20128 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20129 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20130 return 1;
20131 }
20132
20133
20134 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20135 PyObject *pyobj = 0;
20136
20137 {
20138 #if wxUSE_UNICODE
20139 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20140 #else
20141 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20142 #endif
20143 }
20144 return pyobj;
20145 }
20146
20147
20148 SWIGINTERN int ART_WARNING_set(PyObject *) {
20149 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20150 return 1;
20151 }
20152
20153
20154 SWIGINTERN PyObject *ART_WARNING_get(void) {
20155 PyObject *pyobj = 0;
20156
20157 {
20158 #if wxUSE_UNICODE
20159 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20160 #else
20161 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20162 #endif
20163 }
20164 return pyobj;
20165 }
20166
20167
20168 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20169 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20170 return 1;
20171 }
20172
20173
20174 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20175 PyObject *pyobj = 0;
20176
20177 {
20178 #if wxUSE_UNICODE
20179 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20180 #else
20181 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20182 #endif
20183 }
20184 return pyobj;
20185 }
20186
20187
20188 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20189 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20190 return 1;
20191 }
20192
20193
20194 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20195 PyObject *pyobj = 0;
20196
20197 {
20198 #if wxUSE_UNICODE
20199 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20200 #else
20201 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20202 #endif
20203 }
20204 return pyobj;
20205 }
20206
20207
20208 SWIGINTERN int ART_COPY_set(PyObject *) {
20209 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20210 return 1;
20211 }
20212
20213
20214 SWIGINTERN PyObject *ART_COPY_get(void) {
20215 PyObject *pyobj = 0;
20216
20217 {
20218 #if wxUSE_UNICODE
20219 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20220 #else
20221 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20222 #endif
20223 }
20224 return pyobj;
20225 }
20226
20227
20228 SWIGINTERN int ART_CUT_set(PyObject *) {
20229 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20230 return 1;
20231 }
20232
20233
20234 SWIGINTERN PyObject *ART_CUT_get(void) {
20235 PyObject *pyobj = 0;
20236
20237 {
20238 #if wxUSE_UNICODE
20239 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20240 #else
20241 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20242 #endif
20243 }
20244 return pyobj;
20245 }
20246
20247
20248 SWIGINTERN int ART_PASTE_set(PyObject *) {
20249 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20250 return 1;
20251 }
20252
20253
20254 SWIGINTERN PyObject *ART_PASTE_get(void) {
20255 PyObject *pyobj = 0;
20256
20257 {
20258 #if wxUSE_UNICODE
20259 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20260 #else
20261 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20262 #endif
20263 }
20264 return pyobj;
20265 }
20266
20267
20268 SWIGINTERN int ART_DELETE_set(PyObject *) {
20269 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20270 return 1;
20271 }
20272
20273
20274 SWIGINTERN PyObject *ART_DELETE_get(void) {
20275 PyObject *pyobj = 0;
20276
20277 {
20278 #if wxUSE_UNICODE
20279 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20280 #else
20281 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20282 #endif
20283 }
20284 return pyobj;
20285 }
20286
20287
20288 SWIGINTERN int ART_NEW_set(PyObject *) {
20289 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20290 return 1;
20291 }
20292
20293
20294 SWIGINTERN PyObject *ART_NEW_get(void) {
20295 PyObject *pyobj = 0;
20296
20297 {
20298 #if wxUSE_UNICODE
20299 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20300 #else
20301 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20302 #endif
20303 }
20304 return pyobj;
20305 }
20306
20307
20308 SWIGINTERN int ART_UNDO_set(PyObject *) {
20309 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20310 return 1;
20311 }
20312
20313
20314 SWIGINTERN PyObject *ART_UNDO_get(void) {
20315 PyObject *pyobj = 0;
20316
20317 {
20318 #if wxUSE_UNICODE
20319 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20320 #else
20321 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20322 #endif
20323 }
20324 return pyobj;
20325 }
20326
20327
20328 SWIGINTERN int ART_REDO_set(PyObject *) {
20329 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20330 return 1;
20331 }
20332
20333
20334 SWIGINTERN PyObject *ART_REDO_get(void) {
20335 PyObject *pyobj = 0;
20336
20337 {
20338 #if wxUSE_UNICODE
20339 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20340 #else
20341 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20342 #endif
20343 }
20344 return pyobj;
20345 }
20346
20347
20348 SWIGINTERN int ART_QUIT_set(PyObject *) {
20349 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20350 return 1;
20351 }
20352
20353
20354 SWIGINTERN PyObject *ART_QUIT_get(void) {
20355 PyObject *pyobj = 0;
20356
20357 {
20358 #if wxUSE_UNICODE
20359 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20360 #else
20361 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20362 #endif
20363 }
20364 return pyobj;
20365 }
20366
20367
20368 SWIGINTERN int ART_FIND_set(PyObject *) {
20369 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20370 return 1;
20371 }
20372
20373
20374 SWIGINTERN PyObject *ART_FIND_get(void) {
20375 PyObject *pyobj = 0;
20376
20377 {
20378 #if wxUSE_UNICODE
20379 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20380 #else
20381 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20382 #endif
20383 }
20384 return pyobj;
20385 }
20386
20387
20388 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20389 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20390 return 1;
20391 }
20392
20393
20394 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20395 PyObject *pyobj = 0;
20396
20397 {
20398 #if wxUSE_UNICODE
20399 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20400 #else
20401 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20402 #endif
20403 }
20404 return pyobj;
20405 }
20406
20407
20408 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20409 PyObject *resultobj = 0;
20410 wxPyArtProvider *result = 0 ;
20411
20412 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20413 {
20414 if (!wxPyCheckForApp()) SWIG_fail;
20415 PyThreadState* __tstate = wxPyBeginAllowThreads();
20416 result = (wxPyArtProvider *)new wxPyArtProvider();
20417 wxPyEndAllowThreads(__tstate);
20418 if (PyErr_Occurred()) SWIG_fail;
20419 }
20420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20428 PyObject *resultobj = 0;
20429 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20430 void *argp1 = 0 ;
20431 int res1 = 0 ;
20432 PyObject *swig_obj[1] ;
20433
20434 if (!args) SWIG_fail;
20435 swig_obj[0] = args;
20436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20437 if (!SWIG_IsOK(res1)) {
20438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20439 }
20440 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 delete arg1;
20444
20445 wxPyEndAllowThreads(__tstate);
20446 if (PyErr_Occurred()) SWIG_fail;
20447 }
20448 resultobj = SWIG_Py_Void();
20449 return resultobj;
20450 fail:
20451 return NULL;
20452 }
20453
20454
20455 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20456 PyObject *resultobj = 0;
20457 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20458 PyObject *arg2 = (PyObject *) 0 ;
20459 PyObject *arg3 = (PyObject *) 0 ;
20460 void *argp1 = 0 ;
20461 int res1 = 0 ;
20462 PyObject * obj0 = 0 ;
20463 PyObject * obj1 = 0 ;
20464 PyObject * obj2 = 0 ;
20465 char * kwnames[] = {
20466 (char *) "self",(char *) "self",(char *) "_class", NULL
20467 };
20468
20469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20471 if (!SWIG_IsOK(res1)) {
20472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20473 }
20474 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20475 arg2 = obj1;
20476 arg3 = obj2;
20477 {
20478 PyThreadState* __tstate = wxPyBeginAllowThreads();
20479 (arg1)->_setCallbackInfo(arg2,arg3);
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 resultobj = SWIG_Py_Void();
20484 return resultobj;
20485 fail:
20486 return NULL;
20487 }
20488
20489
20490 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20491 PyObject *resultobj = 0;
20492 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20493 int res1 = 0 ;
20494 PyObject * obj0 = 0 ;
20495 char * kwnames[] = {
20496 (char *) "provider", NULL
20497 };
20498
20499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20500 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20501 if (!SWIG_IsOK(res1)) {
20502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20503 }
20504 {
20505 PyThreadState* __tstate = wxPyBeginAllowThreads();
20506 wxPyArtProvider::Push(arg1);
20507 wxPyEndAllowThreads(__tstate);
20508 if (PyErr_Occurred()) SWIG_fail;
20509 }
20510 resultobj = SWIG_Py_Void();
20511 return resultobj;
20512 fail:
20513 return NULL;
20514 }
20515
20516
20517 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20518 PyObject *resultobj = 0;
20519 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20520 int res1 = 0 ;
20521 PyObject * obj0 = 0 ;
20522 char * kwnames[] = {
20523 (char *) "provider", NULL
20524 };
20525
20526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20527 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20528 if (!SWIG_IsOK(res1)) {
20529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20530 }
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 wxPyArtProvider::Insert(arg1);
20534 wxPyEndAllowThreads(__tstate);
20535 if (PyErr_Occurred()) SWIG_fail;
20536 }
20537 resultobj = SWIG_Py_Void();
20538 return resultobj;
20539 fail:
20540 return NULL;
20541 }
20542
20543
20544 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20545 PyObject *resultobj = 0;
20546 bool result;
20547
20548 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20549 {
20550 PyThreadState* __tstate = wxPyBeginAllowThreads();
20551 result = (bool)wxPyArtProvider::Pop();
20552 wxPyEndAllowThreads(__tstate);
20553 if (PyErr_Occurred()) SWIG_fail;
20554 }
20555 {
20556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20557 }
20558 return resultobj;
20559 fail:
20560 return NULL;
20561 }
20562
20563
20564 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20565 PyObject *resultobj = 0;
20566 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20567 bool result;
20568 void *argp1 = 0 ;
20569 int res1 = 0 ;
20570 PyObject * obj0 = 0 ;
20571 char * kwnames[] = {
20572 (char *) "provider", NULL
20573 };
20574
20575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20577 if (!SWIG_IsOK(res1)) {
20578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20579 }
20580 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20581 {
20582 PyThreadState* __tstate = wxPyBeginAllowThreads();
20583 result = (bool)wxPyArtProvider::Delete(arg1);
20584 wxPyEndAllowThreads(__tstate);
20585 if (PyErr_Occurred()) SWIG_fail;
20586 }
20587 {
20588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20589 }
20590 return resultobj;
20591 fail:
20592 return NULL;
20593 }
20594
20595
20596 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20597 PyObject *resultobj = 0;
20598 wxString *arg1 = 0 ;
20599 wxString const &arg2_defvalue = wxPyART_OTHER ;
20600 wxString *arg2 = (wxString *) &arg2_defvalue ;
20601 wxSize const &arg3_defvalue = wxDefaultSize ;
20602 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20603 wxBitmap result;
20604 bool temp1 = false ;
20605 bool temp2 = false ;
20606 wxSize temp3 ;
20607 PyObject * obj0 = 0 ;
20608 PyObject * obj1 = 0 ;
20609 PyObject * obj2 = 0 ;
20610 char * kwnames[] = {
20611 (char *) "id",(char *) "client",(char *) "size", NULL
20612 };
20613
20614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20615 {
20616 arg1 = wxString_in_helper(obj0);
20617 if (arg1 == NULL) SWIG_fail;
20618 temp1 = true;
20619 }
20620 if (obj1) {
20621 {
20622 arg2 = wxString_in_helper(obj1);
20623 if (arg2 == NULL) SWIG_fail;
20624 temp2 = true;
20625 }
20626 }
20627 if (obj2) {
20628 {
20629 arg3 = &temp3;
20630 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20631 }
20632 }
20633 {
20634 if (!wxPyCheckForApp()) SWIG_fail;
20635 PyThreadState* __tstate = wxPyBeginAllowThreads();
20636 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20637 wxPyEndAllowThreads(__tstate);
20638 if (PyErr_Occurred()) SWIG_fail;
20639 }
20640 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20641 {
20642 if (temp1)
20643 delete arg1;
20644 }
20645 {
20646 if (temp2)
20647 delete arg2;
20648 }
20649 return resultobj;
20650 fail:
20651 {
20652 if (temp1)
20653 delete arg1;
20654 }
20655 {
20656 if (temp2)
20657 delete arg2;
20658 }
20659 return NULL;
20660 }
20661
20662
20663 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20664 PyObject *resultobj = 0;
20665 wxString *arg1 = 0 ;
20666 wxString const &arg2_defvalue = wxPyART_OTHER ;
20667 wxString *arg2 = (wxString *) &arg2_defvalue ;
20668 wxSize const &arg3_defvalue = wxDefaultSize ;
20669 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20670 wxIcon result;
20671 bool temp1 = false ;
20672 bool temp2 = false ;
20673 wxSize temp3 ;
20674 PyObject * obj0 = 0 ;
20675 PyObject * obj1 = 0 ;
20676 PyObject * obj2 = 0 ;
20677 char * kwnames[] = {
20678 (char *) "id",(char *) "client",(char *) "size", NULL
20679 };
20680
20681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20682 {
20683 arg1 = wxString_in_helper(obj0);
20684 if (arg1 == NULL) SWIG_fail;
20685 temp1 = true;
20686 }
20687 if (obj1) {
20688 {
20689 arg2 = wxString_in_helper(obj1);
20690 if (arg2 == NULL) SWIG_fail;
20691 temp2 = true;
20692 }
20693 }
20694 if (obj2) {
20695 {
20696 arg3 = &temp3;
20697 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20698 }
20699 }
20700 {
20701 if (!wxPyCheckForApp()) SWIG_fail;
20702 PyThreadState* __tstate = wxPyBeginAllowThreads();
20703 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20704 wxPyEndAllowThreads(__tstate);
20705 if (PyErr_Occurred()) SWIG_fail;
20706 }
20707 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20708 {
20709 if (temp1)
20710 delete arg1;
20711 }
20712 {
20713 if (temp2)
20714 delete arg2;
20715 }
20716 return resultobj;
20717 fail:
20718 {
20719 if (temp1)
20720 delete arg1;
20721 }
20722 {
20723 if (temp2)
20724 delete arg2;
20725 }
20726 return NULL;
20727 }
20728
20729
20730 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20731 PyObject *resultobj = 0;
20732 wxString *arg1 = 0 ;
20733 bool arg2 = (bool) false ;
20734 wxSize result;
20735 bool temp1 = false ;
20736 bool val2 ;
20737 int ecode2 = 0 ;
20738 PyObject * obj0 = 0 ;
20739 PyObject * obj1 = 0 ;
20740 char * kwnames[] = {
20741 (char *) "client",(char *) "platform_dependent", NULL
20742 };
20743
20744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20745 {
20746 arg1 = wxString_in_helper(obj0);
20747 if (arg1 == NULL) SWIG_fail;
20748 temp1 = true;
20749 }
20750 if (obj1) {
20751 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20752 if (!SWIG_IsOK(ecode2)) {
20753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20754 }
20755 arg2 = static_cast< bool >(val2);
20756 }
20757 {
20758 PyThreadState* __tstate = wxPyBeginAllowThreads();
20759 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20764 {
20765 if (temp1)
20766 delete arg1;
20767 }
20768 return resultobj;
20769 fail:
20770 {
20771 if (temp1)
20772 delete arg1;
20773 }
20774 return NULL;
20775 }
20776
20777
20778 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20779 PyObject *resultobj = 0;
20780 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20781 void *argp1 = 0 ;
20782 int res1 = 0 ;
20783 PyObject *swig_obj[1] ;
20784
20785 if (!args) SWIG_fail;
20786 swig_obj[0] = args;
20787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20788 if (!SWIG_IsOK(res1)) {
20789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20790 }
20791 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20792 {
20793 PyThreadState* __tstate = wxPyBeginAllowThreads();
20794 wxPyArtProvider_Destroy(arg1);
20795 wxPyEndAllowThreads(__tstate);
20796 if (PyErr_Occurred()) SWIG_fail;
20797 }
20798 resultobj = SWIG_Py_Void();
20799 return resultobj;
20800 fail:
20801 return NULL;
20802 }
20803
20804
20805 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20806 PyObject *obj;
20807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20808 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20809 return SWIG_Py_Void();
20810 }
20811
20812 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20813 return SWIG_Python_InitShadowInstance(args);
20814 }
20815
20816 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20817 PyObject *resultobj = 0;
20818 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20819 void *argp1 = 0 ;
20820 int res1 = 0 ;
20821 PyObject *swig_obj[1] ;
20822
20823 if (!args) SWIG_fail;
20824 swig_obj[0] = args;
20825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20826 if (!SWIG_IsOK(res1)) {
20827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20828 }
20829 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20830 {
20831 PyThreadState* __tstate = wxPyBeginAllowThreads();
20832 delete arg1;
20833
20834 wxPyEndAllowThreads(__tstate);
20835 if (PyErr_Occurred()) SWIG_fail;
20836 }
20837 resultobj = SWIG_Py_Void();
20838 return resultobj;
20839 fail:
20840 return NULL;
20841 }
20842
20843
20844 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20845 PyObject *resultobj = 0;
20846 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20847 wxConfigBase *result = 0 ;
20848 int res1 = 0 ;
20849 PyObject * obj0 = 0 ;
20850 char * kwnames[] = {
20851 (char *) "config", NULL
20852 };
20853
20854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20855 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20856 if (!SWIG_IsOK(res1)) {
20857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20858 }
20859 {
20860 PyThreadState* __tstate = wxPyBeginAllowThreads();
20861 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20862 wxPyEndAllowThreads(__tstate);
20863 if (PyErr_Occurred()) SWIG_fail;
20864 }
20865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20866 return resultobj;
20867 fail:
20868 return NULL;
20869 }
20870
20871
20872 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20873 PyObject *resultobj = 0;
20874 bool arg1 = (bool) true ;
20875 wxConfigBase *result = 0 ;
20876 bool val1 ;
20877 int ecode1 = 0 ;
20878 PyObject * obj0 = 0 ;
20879 char * kwnames[] = {
20880 (char *) "createOnDemand", NULL
20881 };
20882
20883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20884 if (obj0) {
20885 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20886 if (!SWIG_IsOK(ecode1)) {
20887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20888 }
20889 arg1 = static_cast< bool >(val1);
20890 }
20891 {
20892 PyThreadState* __tstate = wxPyBeginAllowThreads();
20893 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20894 wxPyEndAllowThreads(__tstate);
20895 if (PyErr_Occurred()) SWIG_fail;
20896 }
20897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20898 return resultobj;
20899 fail:
20900 return NULL;
20901 }
20902
20903
20904 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20905 PyObject *resultobj = 0;
20906 wxConfigBase *result = 0 ;
20907
20908 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (wxConfigBase *)wxConfigBase::Create();
20912 wxPyEndAllowThreads(__tstate);
20913 if (PyErr_Occurred()) SWIG_fail;
20914 }
20915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20916 return resultobj;
20917 fail:
20918 return NULL;
20919 }
20920
20921
20922 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20923 PyObject *resultobj = 0;
20924
20925 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 wxConfigBase::DontCreateOnDemand();
20929 wxPyEndAllowThreads(__tstate);
20930 if (PyErr_Occurred()) SWIG_fail;
20931 }
20932 resultobj = SWIG_Py_Void();
20933 return resultobj;
20934 fail:
20935 return NULL;
20936 }
20937
20938
20939 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20940 PyObject *resultobj = 0;
20941 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20942 wxString *arg2 = 0 ;
20943 void *argp1 = 0 ;
20944 int res1 = 0 ;
20945 bool temp2 = false ;
20946 PyObject * obj0 = 0 ;
20947 PyObject * obj1 = 0 ;
20948 char * kwnames[] = {
20949 (char *) "self",(char *) "path", NULL
20950 };
20951
20952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20954 if (!SWIG_IsOK(res1)) {
20955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20956 }
20957 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20958 {
20959 arg2 = wxString_in_helper(obj1);
20960 if (arg2 == NULL) SWIG_fail;
20961 temp2 = true;
20962 }
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 (arg1)->SetPath((wxString const &)*arg2);
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 resultobj = SWIG_Py_Void();
20970 {
20971 if (temp2)
20972 delete arg2;
20973 }
20974 return resultobj;
20975 fail:
20976 {
20977 if (temp2)
20978 delete arg2;
20979 }
20980 return NULL;
20981 }
20982
20983
20984 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20985 PyObject *resultobj = 0;
20986 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20987 wxString *result = 0 ;
20988 void *argp1 = 0 ;
20989 int res1 = 0 ;
20990 PyObject *swig_obj[1] ;
20991
20992 if (!args) SWIG_fail;
20993 swig_obj[0] = args;
20994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20995 if (!SWIG_IsOK(res1)) {
20996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20997 }
20998 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20999 {
21000 PyThreadState* __tstate = wxPyBeginAllowThreads();
21001 {
21002 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21003 result = (wxString *) &_result_ref;
21004 }
21005 wxPyEndAllowThreads(__tstate);
21006 if (PyErr_Occurred()) SWIG_fail;
21007 }
21008 {
21009 #if wxUSE_UNICODE
21010 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21011 #else
21012 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21013 #endif
21014 }
21015 return resultobj;
21016 fail:
21017 return NULL;
21018 }
21019
21020
21021 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21022 PyObject *resultobj = 0;
21023 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21024 PyObject *result = 0 ;
21025 void *argp1 = 0 ;
21026 int res1 = 0 ;
21027 PyObject *swig_obj[1] ;
21028
21029 if (!args) SWIG_fail;
21030 swig_obj[0] = args;
21031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21032 if (!SWIG_IsOK(res1)) {
21033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21034 }
21035 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21039 wxPyEndAllowThreads(__tstate);
21040 if (PyErr_Occurred()) SWIG_fail;
21041 }
21042 resultobj = result;
21043 return resultobj;
21044 fail:
21045 return NULL;
21046 }
21047
21048
21049 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21050 PyObject *resultobj = 0;
21051 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21052 long arg2 ;
21053 PyObject *result = 0 ;
21054 void *argp1 = 0 ;
21055 int res1 = 0 ;
21056 long val2 ;
21057 int ecode2 = 0 ;
21058 PyObject * obj0 = 0 ;
21059 PyObject * obj1 = 0 ;
21060 char * kwnames[] = {
21061 (char *) "self",(char *) "index", NULL
21062 };
21063
21064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21066 if (!SWIG_IsOK(res1)) {
21067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21068 }
21069 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21070 ecode2 = SWIG_AsVal_long(obj1, &val2);
21071 if (!SWIG_IsOK(ecode2)) {
21072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21073 }
21074 arg2 = static_cast< long >(val2);
21075 {
21076 PyThreadState* __tstate = wxPyBeginAllowThreads();
21077 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21078 wxPyEndAllowThreads(__tstate);
21079 if (PyErr_Occurred()) SWIG_fail;
21080 }
21081 resultobj = result;
21082 return resultobj;
21083 fail:
21084 return NULL;
21085 }
21086
21087
21088 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21089 PyObject *resultobj = 0;
21090 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21091 PyObject *result = 0 ;
21092 void *argp1 = 0 ;
21093 int res1 = 0 ;
21094 PyObject *swig_obj[1] ;
21095
21096 if (!args) SWIG_fail;
21097 swig_obj[0] = args;
21098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21099 if (!SWIG_IsOK(res1)) {
21100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21101 }
21102 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21103 {
21104 PyThreadState* __tstate = wxPyBeginAllowThreads();
21105 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 resultobj = result;
21110 return resultobj;
21111 fail:
21112 return NULL;
21113 }
21114
21115
21116 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21117 PyObject *resultobj = 0;
21118 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21119 long arg2 ;
21120 PyObject *result = 0 ;
21121 void *argp1 = 0 ;
21122 int res1 = 0 ;
21123 long val2 ;
21124 int ecode2 = 0 ;
21125 PyObject * obj0 = 0 ;
21126 PyObject * obj1 = 0 ;
21127 char * kwnames[] = {
21128 (char *) "self",(char *) "index", NULL
21129 };
21130
21131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21133 if (!SWIG_IsOK(res1)) {
21134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21135 }
21136 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21137 ecode2 = SWIG_AsVal_long(obj1, &val2);
21138 if (!SWIG_IsOK(ecode2)) {
21139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21140 }
21141 arg2 = static_cast< long >(val2);
21142 {
21143 PyThreadState* __tstate = wxPyBeginAllowThreads();
21144 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21145 wxPyEndAllowThreads(__tstate);
21146 if (PyErr_Occurred()) SWIG_fail;
21147 }
21148 resultobj = result;
21149 return resultobj;
21150 fail:
21151 return NULL;
21152 }
21153
21154
21155 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21156 PyObject *resultobj = 0;
21157 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21158 bool arg2 = (bool) false ;
21159 size_t result;
21160 void *argp1 = 0 ;
21161 int res1 = 0 ;
21162 bool val2 ;
21163 int ecode2 = 0 ;
21164 PyObject * obj0 = 0 ;
21165 PyObject * obj1 = 0 ;
21166 char * kwnames[] = {
21167 (char *) "self",(char *) "recursive", NULL
21168 };
21169
21170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21172 if (!SWIG_IsOK(res1)) {
21173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21174 }
21175 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21176 if (obj1) {
21177 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21178 if (!SWIG_IsOK(ecode2)) {
21179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21180 }
21181 arg2 = static_cast< bool >(val2);
21182 }
21183 {
21184 PyThreadState* __tstate = wxPyBeginAllowThreads();
21185 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21186 wxPyEndAllowThreads(__tstate);
21187 if (PyErr_Occurred()) SWIG_fail;
21188 }
21189 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21190 return resultobj;
21191 fail:
21192 return NULL;
21193 }
21194
21195
21196 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21197 PyObject *resultobj = 0;
21198 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21199 bool arg2 = (bool) false ;
21200 size_t result;
21201 void *argp1 = 0 ;
21202 int res1 = 0 ;
21203 bool val2 ;
21204 int ecode2 = 0 ;
21205 PyObject * obj0 = 0 ;
21206 PyObject * obj1 = 0 ;
21207 char * kwnames[] = {
21208 (char *) "self",(char *) "recursive", NULL
21209 };
21210
21211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21213 if (!SWIG_IsOK(res1)) {
21214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21215 }
21216 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21217 if (obj1) {
21218 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21219 if (!SWIG_IsOK(ecode2)) {
21220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21221 }
21222 arg2 = static_cast< bool >(val2);
21223 }
21224 {
21225 PyThreadState* __tstate = wxPyBeginAllowThreads();
21226 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21227 wxPyEndAllowThreads(__tstate);
21228 if (PyErr_Occurred()) SWIG_fail;
21229 }
21230 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21231 return resultobj;
21232 fail:
21233 return NULL;
21234 }
21235
21236
21237 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21238 PyObject *resultobj = 0;
21239 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21240 wxString *arg2 = 0 ;
21241 bool result;
21242 void *argp1 = 0 ;
21243 int res1 = 0 ;
21244 bool temp2 = false ;
21245 PyObject * obj0 = 0 ;
21246 PyObject * obj1 = 0 ;
21247 char * kwnames[] = {
21248 (char *) "self",(char *) "name", NULL
21249 };
21250
21251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21255 }
21256 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21257 {
21258 arg2 = wxString_in_helper(obj1);
21259 if (arg2 == NULL) SWIG_fail;
21260 temp2 = true;
21261 }
21262 {
21263 PyThreadState* __tstate = wxPyBeginAllowThreads();
21264 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21265 wxPyEndAllowThreads(__tstate);
21266 if (PyErr_Occurred()) SWIG_fail;
21267 }
21268 {
21269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21270 }
21271 {
21272 if (temp2)
21273 delete arg2;
21274 }
21275 return resultobj;
21276 fail:
21277 {
21278 if (temp2)
21279 delete arg2;
21280 }
21281 return NULL;
21282 }
21283
21284
21285 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21286 PyObject *resultobj = 0;
21287 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21288 wxString *arg2 = 0 ;
21289 bool result;
21290 void *argp1 = 0 ;
21291 int res1 = 0 ;
21292 bool temp2 = false ;
21293 PyObject * obj0 = 0 ;
21294 PyObject * obj1 = 0 ;
21295 char * kwnames[] = {
21296 (char *) "self",(char *) "name", NULL
21297 };
21298
21299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21301 if (!SWIG_IsOK(res1)) {
21302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21303 }
21304 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21305 {
21306 arg2 = wxString_in_helper(obj1);
21307 if (arg2 == NULL) SWIG_fail;
21308 temp2 = true;
21309 }
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 {
21317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21318 }
21319 {
21320 if (temp2)
21321 delete arg2;
21322 }
21323 return resultobj;
21324 fail:
21325 {
21326 if (temp2)
21327 delete arg2;
21328 }
21329 return NULL;
21330 }
21331
21332
21333 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21334 PyObject *resultobj = 0;
21335 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21336 wxString *arg2 = 0 ;
21337 bool result;
21338 void *argp1 = 0 ;
21339 int res1 = 0 ;
21340 bool temp2 = false ;
21341 PyObject * obj0 = 0 ;
21342 PyObject * obj1 = 0 ;
21343 char * kwnames[] = {
21344 (char *) "self",(char *) "name", NULL
21345 };
21346
21347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21349 if (!SWIG_IsOK(res1)) {
21350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21351 }
21352 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21353 {
21354 arg2 = wxString_in_helper(obj1);
21355 if (arg2 == NULL) SWIG_fail;
21356 temp2 = true;
21357 }
21358 {
21359 PyThreadState* __tstate = wxPyBeginAllowThreads();
21360 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21361 wxPyEndAllowThreads(__tstate);
21362 if (PyErr_Occurred()) SWIG_fail;
21363 }
21364 {
21365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21366 }
21367 {
21368 if (temp2)
21369 delete arg2;
21370 }
21371 return resultobj;
21372 fail:
21373 {
21374 if (temp2)
21375 delete arg2;
21376 }
21377 return NULL;
21378 }
21379
21380
21381 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21382 PyObject *resultobj = 0;
21383 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21384 wxString *arg2 = 0 ;
21385 wxConfigBase::EntryType result;
21386 void *argp1 = 0 ;
21387 int res1 = 0 ;
21388 bool temp2 = false ;
21389 PyObject * obj0 = 0 ;
21390 PyObject * obj1 = 0 ;
21391 char * kwnames[] = {
21392 (char *) "self",(char *) "name", NULL
21393 };
21394
21395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21397 if (!SWIG_IsOK(res1)) {
21398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21399 }
21400 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21401 {
21402 arg2 = wxString_in_helper(obj1);
21403 if (arg2 == NULL) SWIG_fail;
21404 temp2 = true;
21405 }
21406 {
21407 PyThreadState* __tstate = wxPyBeginAllowThreads();
21408 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21409 wxPyEndAllowThreads(__tstate);
21410 if (PyErr_Occurred()) SWIG_fail;
21411 }
21412 resultobj = SWIG_From_int(static_cast< int >(result));
21413 {
21414 if (temp2)
21415 delete arg2;
21416 }
21417 return resultobj;
21418 fail:
21419 {
21420 if (temp2)
21421 delete arg2;
21422 }
21423 return NULL;
21424 }
21425
21426
21427 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21428 PyObject *resultobj = 0;
21429 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21430 wxString *arg2 = 0 ;
21431 wxString const &arg3_defvalue = wxPyEmptyString ;
21432 wxString *arg3 = (wxString *) &arg3_defvalue ;
21433 wxString result;
21434 void *argp1 = 0 ;
21435 int res1 = 0 ;
21436 bool temp2 = false ;
21437 bool temp3 = false ;
21438 PyObject * obj0 = 0 ;
21439 PyObject * obj1 = 0 ;
21440 PyObject * obj2 = 0 ;
21441 char * kwnames[] = {
21442 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21443 };
21444
21445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21447 if (!SWIG_IsOK(res1)) {
21448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21449 }
21450 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21451 {
21452 arg2 = wxString_in_helper(obj1);
21453 if (arg2 == NULL) SWIG_fail;
21454 temp2 = true;
21455 }
21456 if (obj2) {
21457 {
21458 arg3 = wxString_in_helper(obj2);
21459 if (arg3 == NULL) SWIG_fail;
21460 temp3 = true;
21461 }
21462 }
21463 {
21464 PyThreadState* __tstate = wxPyBeginAllowThreads();
21465 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 {
21470 #if wxUSE_UNICODE
21471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21472 #else
21473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21474 #endif
21475 }
21476 {
21477 if (temp2)
21478 delete arg2;
21479 }
21480 {
21481 if (temp3)
21482 delete arg3;
21483 }
21484 return resultobj;
21485 fail:
21486 {
21487 if (temp2)
21488 delete arg2;
21489 }
21490 {
21491 if (temp3)
21492 delete arg3;
21493 }
21494 return NULL;
21495 }
21496
21497
21498 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21499 PyObject *resultobj = 0;
21500 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21501 wxString *arg2 = 0 ;
21502 long arg3 = (long) 0 ;
21503 long result;
21504 void *argp1 = 0 ;
21505 int res1 = 0 ;
21506 bool temp2 = false ;
21507 long val3 ;
21508 int ecode3 = 0 ;
21509 PyObject * obj0 = 0 ;
21510 PyObject * obj1 = 0 ;
21511 PyObject * obj2 = 0 ;
21512 char * kwnames[] = {
21513 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21514 };
21515
21516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21518 if (!SWIG_IsOK(res1)) {
21519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21520 }
21521 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21522 {
21523 arg2 = wxString_in_helper(obj1);
21524 if (arg2 == NULL) SWIG_fail;
21525 temp2 = true;
21526 }
21527 if (obj2) {
21528 ecode3 = SWIG_AsVal_long(obj2, &val3);
21529 if (!SWIG_IsOK(ecode3)) {
21530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21531 }
21532 arg3 = static_cast< long >(val3);
21533 }
21534 {
21535 PyThreadState* __tstate = wxPyBeginAllowThreads();
21536 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21537 wxPyEndAllowThreads(__tstate);
21538 if (PyErr_Occurred()) SWIG_fail;
21539 }
21540 resultobj = SWIG_From_long(static_cast< long >(result));
21541 {
21542 if (temp2)
21543 delete arg2;
21544 }
21545 return resultobj;
21546 fail:
21547 {
21548 if (temp2)
21549 delete arg2;
21550 }
21551 return NULL;
21552 }
21553
21554
21555 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21556 PyObject *resultobj = 0;
21557 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21558 wxString *arg2 = 0 ;
21559 double arg3 = (double) 0.0 ;
21560 double result;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 bool temp2 = false ;
21564 double val3 ;
21565 int ecode3 = 0 ;
21566 PyObject * obj0 = 0 ;
21567 PyObject * obj1 = 0 ;
21568 PyObject * obj2 = 0 ;
21569 char * kwnames[] = {
21570 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21571 };
21572
21573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21575 if (!SWIG_IsOK(res1)) {
21576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21577 }
21578 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21579 {
21580 arg2 = wxString_in_helper(obj1);
21581 if (arg2 == NULL) SWIG_fail;
21582 temp2 = true;
21583 }
21584 if (obj2) {
21585 ecode3 = SWIG_AsVal_double(obj2, &val3);
21586 if (!SWIG_IsOK(ecode3)) {
21587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21588 }
21589 arg3 = static_cast< double >(val3);
21590 }
21591 {
21592 PyThreadState* __tstate = wxPyBeginAllowThreads();
21593 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21594 wxPyEndAllowThreads(__tstate);
21595 if (PyErr_Occurred()) SWIG_fail;
21596 }
21597 resultobj = SWIG_From_double(static_cast< double >(result));
21598 {
21599 if (temp2)
21600 delete arg2;
21601 }
21602 return resultobj;
21603 fail:
21604 {
21605 if (temp2)
21606 delete arg2;
21607 }
21608 return NULL;
21609 }
21610
21611
21612 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21613 PyObject *resultobj = 0;
21614 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21615 wxString *arg2 = 0 ;
21616 bool arg3 = (bool) false ;
21617 bool result;
21618 void *argp1 = 0 ;
21619 int res1 = 0 ;
21620 bool temp2 = false ;
21621 bool val3 ;
21622 int ecode3 = 0 ;
21623 PyObject * obj0 = 0 ;
21624 PyObject * obj1 = 0 ;
21625 PyObject * obj2 = 0 ;
21626 char * kwnames[] = {
21627 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21628 };
21629
21630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21632 if (!SWIG_IsOK(res1)) {
21633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21634 }
21635 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21636 {
21637 arg2 = wxString_in_helper(obj1);
21638 if (arg2 == NULL) SWIG_fail;
21639 temp2 = true;
21640 }
21641 if (obj2) {
21642 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21643 if (!SWIG_IsOK(ecode3)) {
21644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21645 }
21646 arg3 = static_cast< bool >(val3);
21647 }
21648 {
21649 PyThreadState* __tstate = wxPyBeginAllowThreads();
21650 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21651 wxPyEndAllowThreads(__tstate);
21652 if (PyErr_Occurred()) SWIG_fail;
21653 }
21654 {
21655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21656 }
21657 {
21658 if (temp2)
21659 delete arg2;
21660 }
21661 return resultobj;
21662 fail:
21663 {
21664 if (temp2)
21665 delete arg2;
21666 }
21667 return NULL;
21668 }
21669
21670
21671 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21672 PyObject *resultobj = 0;
21673 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21674 wxString *arg2 = 0 ;
21675 wxString *arg3 = 0 ;
21676 bool result;
21677 void *argp1 = 0 ;
21678 int res1 = 0 ;
21679 bool temp2 = false ;
21680 bool temp3 = false ;
21681 PyObject * obj0 = 0 ;
21682 PyObject * obj1 = 0 ;
21683 PyObject * obj2 = 0 ;
21684 char * kwnames[] = {
21685 (char *) "self",(char *) "key",(char *) "value", NULL
21686 };
21687
21688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21690 if (!SWIG_IsOK(res1)) {
21691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21692 }
21693 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21694 {
21695 arg2 = wxString_in_helper(obj1);
21696 if (arg2 == NULL) SWIG_fail;
21697 temp2 = true;
21698 }
21699 {
21700 arg3 = wxString_in_helper(obj2);
21701 if (arg3 == NULL) SWIG_fail;
21702 temp3 = true;
21703 }
21704 {
21705 PyThreadState* __tstate = wxPyBeginAllowThreads();
21706 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21707 wxPyEndAllowThreads(__tstate);
21708 if (PyErr_Occurred()) SWIG_fail;
21709 }
21710 {
21711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21712 }
21713 {
21714 if (temp2)
21715 delete arg2;
21716 }
21717 {
21718 if (temp3)
21719 delete arg3;
21720 }
21721 return resultobj;
21722 fail:
21723 {
21724 if (temp2)
21725 delete arg2;
21726 }
21727 {
21728 if (temp3)
21729 delete arg3;
21730 }
21731 return NULL;
21732 }
21733
21734
21735 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21736 PyObject *resultobj = 0;
21737 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21738 wxString *arg2 = 0 ;
21739 long arg3 ;
21740 bool result;
21741 void *argp1 = 0 ;
21742 int res1 = 0 ;
21743 bool temp2 = false ;
21744 long val3 ;
21745 int ecode3 = 0 ;
21746 PyObject * obj0 = 0 ;
21747 PyObject * obj1 = 0 ;
21748 PyObject * obj2 = 0 ;
21749 char * kwnames[] = {
21750 (char *) "self",(char *) "key",(char *) "value", NULL
21751 };
21752
21753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21755 if (!SWIG_IsOK(res1)) {
21756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21757 }
21758 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21759 {
21760 arg2 = wxString_in_helper(obj1);
21761 if (arg2 == NULL) SWIG_fail;
21762 temp2 = true;
21763 }
21764 ecode3 = SWIG_AsVal_long(obj2, &val3);
21765 if (!SWIG_IsOK(ecode3)) {
21766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21767 }
21768 arg3 = static_cast< long >(val3);
21769 {
21770 PyThreadState* __tstate = wxPyBeginAllowThreads();
21771 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21772 wxPyEndAllowThreads(__tstate);
21773 if (PyErr_Occurred()) SWIG_fail;
21774 }
21775 {
21776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21777 }
21778 {
21779 if (temp2)
21780 delete arg2;
21781 }
21782 return resultobj;
21783 fail:
21784 {
21785 if (temp2)
21786 delete arg2;
21787 }
21788 return NULL;
21789 }
21790
21791
21792 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21793 PyObject *resultobj = 0;
21794 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21795 wxString *arg2 = 0 ;
21796 double arg3 ;
21797 bool result;
21798 void *argp1 = 0 ;
21799 int res1 = 0 ;
21800 bool temp2 = false ;
21801 double val3 ;
21802 int ecode3 = 0 ;
21803 PyObject * obj0 = 0 ;
21804 PyObject * obj1 = 0 ;
21805 PyObject * obj2 = 0 ;
21806 char * kwnames[] = {
21807 (char *) "self",(char *) "key",(char *) "value", NULL
21808 };
21809
21810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21812 if (!SWIG_IsOK(res1)) {
21813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21814 }
21815 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21816 {
21817 arg2 = wxString_in_helper(obj1);
21818 if (arg2 == NULL) SWIG_fail;
21819 temp2 = true;
21820 }
21821 ecode3 = SWIG_AsVal_double(obj2, &val3);
21822 if (!SWIG_IsOK(ecode3)) {
21823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21824 }
21825 arg3 = static_cast< double >(val3);
21826 {
21827 PyThreadState* __tstate = wxPyBeginAllowThreads();
21828 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21829 wxPyEndAllowThreads(__tstate);
21830 if (PyErr_Occurred()) SWIG_fail;
21831 }
21832 {
21833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21834 }
21835 {
21836 if (temp2)
21837 delete arg2;
21838 }
21839 return resultobj;
21840 fail:
21841 {
21842 if (temp2)
21843 delete arg2;
21844 }
21845 return NULL;
21846 }
21847
21848
21849 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21850 PyObject *resultobj = 0;
21851 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21852 wxString *arg2 = 0 ;
21853 bool arg3 ;
21854 bool result;
21855 void *argp1 = 0 ;
21856 int res1 = 0 ;
21857 bool temp2 = false ;
21858 bool val3 ;
21859 int ecode3 = 0 ;
21860 PyObject * obj0 = 0 ;
21861 PyObject * obj1 = 0 ;
21862 PyObject * obj2 = 0 ;
21863 char * kwnames[] = {
21864 (char *) "self",(char *) "key",(char *) "value", NULL
21865 };
21866
21867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21869 if (!SWIG_IsOK(res1)) {
21870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21871 }
21872 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21873 {
21874 arg2 = wxString_in_helper(obj1);
21875 if (arg2 == NULL) SWIG_fail;
21876 temp2 = true;
21877 }
21878 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21879 if (!SWIG_IsOK(ecode3)) {
21880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21881 }
21882 arg3 = static_cast< bool >(val3);
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 {
21890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21891 }
21892 {
21893 if (temp2)
21894 delete arg2;
21895 }
21896 return resultobj;
21897 fail:
21898 {
21899 if (temp2)
21900 delete arg2;
21901 }
21902 return NULL;
21903 }
21904
21905
21906 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21907 PyObject *resultobj = 0;
21908 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21909 bool arg2 = (bool) false ;
21910 bool result;
21911 void *argp1 = 0 ;
21912 int res1 = 0 ;
21913 bool val2 ;
21914 int ecode2 = 0 ;
21915 PyObject * obj0 = 0 ;
21916 PyObject * obj1 = 0 ;
21917 char * kwnames[] = {
21918 (char *) "self",(char *) "currentOnly", NULL
21919 };
21920
21921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21923 if (!SWIG_IsOK(res1)) {
21924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21925 }
21926 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21927 if (obj1) {
21928 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21929 if (!SWIG_IsOK(ecode2)) {
21930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21931 }
21932 arg2 = static_cast< bool >(val2);
21933 }
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = (bool)(arg1)->Flush(arg2);
21937 wxPyEndAllowThreads(__tstate);
21938 if (PyErr_Occurred()) SWIG_fail;
21939 }
21940 {
21941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21942 }
21943 return resultobj;
21944 fail:
21945 return NULL;
21946 }
21947
21948
21949 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21950 PyObject *resultobj = 0;
21951 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21952 wxString *arg2 = 0 ;
21953 wxString *arg3 = 0 ;
21954 bool result;
21955 void *argp1 = 0 ;
21956 int res1 = 0 ;
21957 bool temp2 = false ;
21958 bool temp3 = false ;
21959 PyObject * obj0 = 0 ;
21960 PyObject * obj1 = 0 ;
21961 PyObject * obj2 = 0 ;
21962 char * kwnames[] = {
21963 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21964 };
21965
21966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21968 if (!SWIG_IsOK(res1)) {
21969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21970 }
21971 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21972 {
21973 arg2 = wxString_in_helper(obj1);
21974 if (arg2 == NULL) SWIG_fail;
21975 temp2 = true;
21976 }
21977 {
21978 arg3 = wxString_in_helper(obj2);
21979 if (arg3 == NULL) SWIG_fail;
21980 temp3 = true;
21981 }
21982 {
21983 PyThreadState* __tstate = wxPyBeginAllowThreads();
21984 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21985 wxPyEndAllowThreads(__tstate);
21986 if (PyErr_Occurred()) SWIG_fail;
21987 }
21988 {
21989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21990 }
21991 {
21992 if (temp2)
21993 delete arg2;
21994 }
21995 {
21996 if (temp3)
21997 delete arg3;
21998 }
21999 return resultobj;
22000 fail:
22001 {
22002 if (temp2)
22003 delete arg2;
22004 }
22005 {
22006 if (temp3)
22007 delete arg3;
22008 }
22009 return NULL;
22010 }
22011
22012
22013 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22014 PyObject *resultobj = 0;
22015 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22016 wxString *arg2 = 0 ;
22017 wxString *arg3 = 0 ;
22018 bool result;
22019 void *argp1 = 0 ;
22020 int res1 = 0 ;
22021 bool temp2 = false ;
22022 bool temp3 = false ;
22023 PyObject * obj0 = 0 ;
22024 PyObject * obj1 = 0 ;
22025 PyObject * obj2 = 0 ;
22026 char * kwnames[] = {
22027 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22028 };
22029
22030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22032 if (!SWIG_IsOK(res1)) {
22033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22034 }
22035 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22036 {
22037 arg2 = wxString_in_helper(obj1);
22038 if (arg2 == NULL) SWIG_fail;
22039 temp2 = true;
22040 }
22041 {
22042 arg3 = wxString_in_helper(obj2);
22043 if (arg3 == NULL) SWIG_fail;
22044 temp3 = true;
22045 }
22046 {
22047 PyThreadState* __tstate = wxPyBeginAllowThreads();
22048 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22049 wxPyEndAllowThreads(__tstate);
22050 if (PyErr_Occurred()) SWIG_fail;
22051 }
22052 {
22053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22054 }
22055 {
22056 if (temp2)
22057 delete arg2;
22058 }
22059 {
22060 if (temp3)
22061 delete arg3;
22062 }
22063 return resultobj;
22064 fail:
22065 {
22066 if (temp2)
22067 delete arg2;
22068 }
22069 {
22070 if (temp3)
22071 delete arg3;
22072 }
22073 return NULL;
22074 }
22075
22076
22077 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22078 PyObject *resultobj = 0;
22079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22080 wxString *arg2 = 0 ;
22081 bool arg3 = (bool) true ;
22082 bool result;
22083 void *argp1 = 0 ;
22084 int res1 = 0 ;
22085 bool temp2 = false ;
22086 bool val3 ;
22087 int ecode3 = 0 ;
22088 PyObject * obj0 = 0 ;
22089 PyObject * obj1 = 0 ;
22090 PyObject * obj2 = 0 ;
22091 char * kwnames[] = {
22092 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22093 };
22094
22095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22097 if (!SWIG_IsOK(res1)) {
22098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22099 }
22100 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22101 {
22102 arg2 = wxString_in_helper(obj1);
22103 if (arg2 == NULL) SWIG_fail;
22104 temp2 = true;
22105 }
22106 if (obj2) {
22107 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22108 if (!SWIG_IsOK(ecode3)) {
22109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22110 }
22111 arg3 = static_cast< bool >(val3);
22112 }
22113 {
22114 PyThreadState* __tstate = wxPyBeginAllowThreads();
22115 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22116 wxPyEndAllowThreads(__tstate);
22117 if (PyErr_Occurred()) SWIG_fail;
22118 }
22119 {
22120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22121 }
22122 {
22123 if (temp2)
22124 delete arg2;
22125 }
22126 return resultobj;
22127 fail:
22128 {
22129 if (temp2)
22130 delete arg2;
22131 }
22132 return NULL;
22133 }
22134
22135
22136 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22137 PyObject *resultobj = 0;
22138 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22139 wxString *arg2 = 0 ;
22140 bool result;
22141 void *argp1 = 0 ;
22142 int res1 = 0 ;
22143 bool temp2 = false ;
22144 PyObject * obj0 = 0 ;
22145 PyObject * obj1 = 0 ;
22146 char * kwnames[] = {
22147 (char *) "self",(char *) "key", NULL
22148 };
22149
22150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22152 if (!SWIG_IsOK(res1)) {
22153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22154 }
22155 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22156 {
22157 arg2 = wxString_in_helper(obj1);
22158 if (arg2 == NULL) SWIG_fail;
22159 temp2 = true;
22160 }
22161 {
22162 PyThreadState* __tstate = wxPyBeginAllowThreads();
22163 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22164 wxPyEndAllowThreads(__tstate);
22165 if (PyErr_Occurred()) SWIG_fail;
22166 }
22167 {
22168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22169 }
22170 {
22171 if (temp2)
22172 delete arg2;
22173 }
22174 return resultobj;
22175 fail:
22176 {
22177 if (temp2)
22178 delete arg2;
22179 }
22180 return NULL;
22181 }
22182
22183
22184 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22185 PyObject *resultobj = 0;
22186 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22187 bool result;
22188 void *argp1 = 0 ;
22189 int res1 = 0 ;
22190 PyObject *swig_obj[1] ;
22191
22192 if (!args) SWIG_fail;
22193 swig_obj[0] = args;
22194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22195 if (!SWIG_IsOK(res1)) {
22196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22197 }
22198 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22199 {
22200 PyThreadState* __tstate = wxPyBeginAllowThreads();
22201 result = (bool)(arg1)->DeleteAll();
22202 wxPyEndAllowThreads(__tstate);
22203 if (PyErr_Occurred()) SWIG_fail;
22204 }
22205 {
22206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22207 }
22208 return resultobj;
22209 fail:
22210 return NULL;
22211 }
22212
22213
22214 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22215 PyObject *resultobj = 0;
22216 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22217 bool arg2 = (bool) true ;
22218 void *argp1 = 0 ;
22219 int res1 = 0 ;
22220 bool val2 ;
22221 int ecode2 = 0 ;
22222 PyObject * obj0 = 0 ;
22223 PyObject * obj1 = 0 ;
22224 char * kwnames[] = {
22225 (char *) "self",(char *) "doIt", NULL
22226 };
22227
22228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22230 if (!SWIG_IsOK(res1)) {
22231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22232 }
22233 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22234 if (obj1) {
22235 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22236 if (!SWIG_IsOK(ecode2)) {
22237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22238 }
22239 arg2 = static_cast< bool >(val2);
22240 }
22241 {
22242 PyThreadState* __tstate = wxPyBeginAllowThreads();
22243 (arg1)->SetExpandEnvVars(arg2);
22244 wxPyEndAllowThreads(__tstate);
22245 if (PyErr_Occurred()) SWIG_fail;
22246 }
22247 resultobj = SWIG_Py_Void();
22248 return resultobj;
22249 fail:
22250 return NULL;
22251 }
22252
22253
22254 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22255 PyObject *resultobj = 0;
22256 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22257 bool result;
22258 void *argp1 = 0 ;
22259 int res1 = 0 ;
22260 PyObject *swig_obj[1] ;
22261
22262 if (!args) SWIG_fail;
22263 swig_obj[0] = args;
22264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22265 if (!SWIG_IsOK(res1)) {
22266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22267 }
22268 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22269 {
22270 PyThreadState* __tstate = wxPyBeginAllowThreads();
22271 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22272 wxPyEndAllowThreads(__tstate);
22273 if (PyErr_Occurred()) SWIG_fail;
22274 }
22275 {
22276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22277 }
22278 return resultobj;
22279 fail:
22280 return NULL;
22281 }
22282
22283
22284 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22285 PyObject *resultobj = 0;
22286 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22287 bool arg2 = (bool) true ;
22288 void *argp1 = 0 ;
22289 int res1 = 0 ;
22290 bool val2 ;
22291 int ecode2 = 0 ;
22292 PyObject * obj0 = 0 ;
22293 PyObject * obj1 = 0 ;
22294 char * kwnames[] = {
22295 (char *) "self",(char *) "doIt", NULL
22296 };
22297
22298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22300 if (!SWIG_IsOK(res1)) {
22301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22302 }
22303 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22304 if (obj1) {
22305 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22306 if (!SWIG_IsOK(ecode2)) {
22307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22308 }
22309 arg2 = static_cast< bool >(val2);
22310 }
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 (arg1)->SetRecordDefaults(arg2);
22314 wxPyEndAllowThreads(__tstate);
22315 if (PyErr_Occurred()) SWIG_fail;
22316 }
22317 resultobj = SWIG_Py_Void();
22318 return resultobj;
22319 fail:
22320 return NULL;
22321 }
22322
22323
22324 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22325 PyObject *resultobj = 0;
22326 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22327 bool result;
22328 void *argp1 = 0 ;
22329 int res1 = 0 ;
22330 PyObject *swig_obj[1] ;
22331
22332 if (!args) SWIG_fail;
22333 swig_obj[0] = args;
22334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22335 if (!SWIG_IsOK(res1)) {
22336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22337 }
22338 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22339 {
22340 PyThreadState* __tstate = wxPyBeginAllowThreads();
22341 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 {
22346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22347 }
22348 return resultobj;
22349 fail:
22350 return NULL;
22351 }
22352
22353
22354 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22355 PyObject *resultobj = 0;
22356 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22357 wxString *arg2 = 0 ;
22358 wxString result;
22359 void *argp1 = 0 ;
22360 int res1 = 0 ;
22361 bool temp2 = false ;
22362 PyObject * obj0 = 0 ;
22363 PyObject * obj1 = 0 ;
22364 char * kwnames[] = {
22365 (char *) "self",(char *) "str", NULL
22366 };
22367
22368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22370 if (!SWIG_IsOK(res1)) {
22371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22372 }
22373 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22374 {
22375 arg2 = wxString_in_helper(obj1);
22376 if (arg2 == NULL) SWIG_fail;
22377 temp2 = true;
22378 }
22379 {
22380 PyThreadState* __tstate = wxPyBeginAllowThreads();
22381 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22382 wxPyEndAllowThreads(__tstate);
22383 if (PyErr_Occurred()) SWIG_fail;
22384 }
22385 {
22386 #if wxUSE_UNICODE
22387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22388 #else
22389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22390 #endif
22391 }
22392 {
22393 if (temp2)
22394 delete arg2;
22395 }
22396 return resultobj;
22397 fail:
22398 {
22399 if (temp2)
22400 delete arg2;
22401 }
22402 return NULL;
22403 }
22404
22405
22406 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22407 PyObject *resultobj = 0;
22408 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22409 wxString result;
22410 void *argp1 = 0 ;
22411 int res1 = 0 ;
22412 PyObject *swig_obj[1] ;
22413
22414 if (!args) SWIG_fail;
22415 swig_obj[0] = args;
22416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22417 if (!SWIG_IsOK(res1)) {
22418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22419 }
22420 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22421 {
22422 PyThreadState* __tstate = wxPyBeginAllowThreads();
22423 result = ((wxConfigBase const *)arg1)->GetAppName();
22424 wxPyEndAllowThreads(__tstate);
22425 if (PyErr_Occurred()) SWIG_fail;
22426 }
22427 {
22428 #if wxUSE_UNICODE
22429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22430 #else
22431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22432 #endif
22433 }
22434 return resultobj;
22435 fail:
22436 return NULL;
22437 }
22438
22439
22440 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22441 PyObject *resultobj = 0;
22442 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22443 wxString result;
22444 void *argp1 = 0 ;
22445 int res1 = 0 ;
22446 PyObject *swig_obj[1] ;
22447
22448 if (!args) SWIG_fail;
22449 swig_obj[0] = args;
22450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22451 if (!SWIG_IsOK(res1)) {
22452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22453 }
22454 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22455 {
22456 PyThreadState* __tstate = wxPyBeginAllowThreads();
22457 result = ((wxConfigBase const *)arg1)->GetVendorName();
22458 wxPyEndAllowThreads(__tstate);
22459 if (PyErr_Occurred()) SWIG_fail;
22460 }
22461 {
22462 #if wxUSE_UNICODE
22463 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22464 #else
22465 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22466 #endif
22467 }
22468 return resultobj;
22469 fail:
22470 return NULL;
22471 }
22472
22473
22474 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22475 PyObject *resultobj = 0;
22476 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22477 wxString *arg2 = 0 ;
22478 void *argp1 = 0 ;
22479 int res1 = 0 ;
22480 bool temp2 = false ;
22481 PyObject * obj0 = 0 ;
22482 PyObject * obj1 = 0 ;
22483 char * kwnames[] = {
22484 (char *) "self",(char *) "appName", NULL
22485 };
22486
22487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22489 if (!SWIG_IsOK(res1)) {
22490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22491 }
22492 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22493 {
22494 arg2 = wxString_in_helper(obj1);
22495 if (arg2 == NULL) SWIG_fail;
22496 temp2 = true;
22497 }
22498 {
22499 PyThreadState* __tstate = wxPyBeginAllowThreads();
22500 (arg1)->SetAppName((wxString const &)*arg2);
22501 wxPyEndAllowThreads(__tstate);
22502 if (PyErr_Occurred()) SWIG_fail;
22503 }
22504 resultobj = SWIG_Py_Void();
22505 {
22506 if (temp2)
22507 delete arg2;
22508 }
22509 return resultobj;
22510 fail:
22511 {
22512 if (temp2)
22513 delete arg2;
22514 }
22515 return NULL;
22516 }
22517
22518
22519 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22520 PyObject *resultobj = 0;
22521 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22522 wxString *arg2 = 0 ;
22523 void *argp1 = 0 ;
22524 int res1 = 0 ;
22525 bool temp2 = false ;
22526 PyObject * obj0 = 0 ;
22527 PyObject * obj1 = 0 ;
22528 char * kwnames[] = {
22529 (char *) "self",(char *) "vendorName", NULL
22530 };
22531
22532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22534 if (!SWIG_IsOK(res1)) {
22535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22536 }
22537 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22538 {
22539 arg2 = wxString_in_helper(obj1);
22540 if (arg2 == NULL) SWIG_fail;
22541 temp2 = true;
22542 }
22543 {
22544 PyThreadState* __tstate = wxPyBeginAllowThreads();
22545 (arg1)->SetVendorName((wxString const &)*arg2);
22546 wxPyEndAllowThreads(__tstate);
22547 if (PyErr_Occurred()) SWIG_fail;
22548 }
22549 resultobj = SWIG_Py_Void();
22550 {
22551 if (temp2)
22552 delete arg2;
22553 }
22554 return resultobj;
22555 fail:
22556 {
22557 if (temp2)
22558 delete arg2;
22559 }
22560 return NULL;
22561 }
22562
22563
22564 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22565 PyObject *resultobj = 0;
22566 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22567 long arg2 ;
22568 void *argp1 = 0 ;
22569 int res1 = 0 ;
22570 long val2 ;
22571 int ecode2 = 0 ;
22572 PyObject * obj0 = 0 ;
22573 PyObject * obj1 = 0 ;
22574 char * kwnames[] = {
22575 (char *) "self",(char *) "style", NULL
22576 };
22577
22578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22580 if (!SWIG_IsOK(res1)) {
22581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22582 }
22583 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22584 ecode2 = SWIG_AsVal_long(obj1, &val2);
22585 if (!SWIG_IsOK(ecode2)) {
22586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22587 }
22588 arg2 = static_cast< long >(val2);
22589 {
22590 PyThreadState* __tstate = wxPyBeginAllowThreads();
22591 (arg1)->SetStyle(arg2);
22592 wxPyEndAllowThreads(__tstate);
22593 if (PyErr_Occurred()) SWIG_fail;
22594 }
22595 resultobj = SWIG_Py_Void();
22596 return resultobj;
22597 fail:
22598 return NULL;
22599 }
22600
22601
22602 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22603 PyObject *resultobj = 0;
22604 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22605 long result;
22606 void *argp1 = 0 ;
22607 int res1 = 0 ;
22608 PyObject *swig_obj[1] ;
22609
22610 if (!args) SWIG_fail;
22611 swig_obj[0] = args;
22612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22613 if (!SWIG_IsOK(res1)) {
22614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22615 }
22616 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22617 {
22618 PyThreadState* __tstate = wxPyBeginAllowThreads();
22619 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22620 wxPyEndAllowThreads(__tstate);
22621 if (PyErr_Occurred()) SWIG_fail;
22622 }
22623 resultobj = SWIG_From_long(static_cast< long >(result));
22624 return resultobj;
22625 fail:
22626 return NULL;
22627 }
22628
22629
22630 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22631 PyObject *obj;
22632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22633 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22634 return SWIG_Py_Void();
22635 }
22636
22637 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22638 PyObject *resultobj = 0;
22639 wxString const &arg1_defvalue = wxPyEmptyString ;
22640 wxString *arg1 = (wxString *) &arg1_defvalue ;
22641 wxString const &arg2_defvalue = wxPyEmptyString ;
22642 wxString *arg2 = (wxString *) &arg2_defvalue ;
22643 wxString const &arg3_defvalue = wxPyEmptyString ;
22644 wxString *arg3 = (wxString *) &arg3_defvalue ;
22645 wxString const &arg4_defvalue = wxPyEmptyString ;
22646 wxString *arg4 = (wxString *) &arg4_defvalue ;
22647 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22648 wxConfig *result = 0 ;
22649 bool temp1 = false ;
22650 bool temp2 = false ;
22651 bool temp3 = false ;
22652 bool temp4 = false ;
22653 long val5 ;
22654 int ecode5 = 0 ;
22655 PyObject * obj0 = 0 ;
22656 PyObject * obj1 = 0 ;
22657 PyObject * obj2 = 0 ;
22658 PyObject * obj3 = 0 ;
22659 PyObject * obj4 = 0 ;
22660 char * kwnames[] = {
22661 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22662 };
22663
22664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22665 if (obj0) {
22666 {
22667 arg1 = wxString_in_helper(obj0);
22668 if (arg1 == NULL) SWIG_fail;
22669 temp1 = true;
22670 }
22671 }
22672 if (obj1) {
22673 {
22674 arg2 = wxString_in_helper(obj1);
22675 if (arg2 == NULL) SWIG_fail;
22676 temp2 = true;
22677 }
22678 }
22679 if (obj2) {
22680 {
22681 arg3 = wxString_in_helper(obj2);
22682 if (arg3 == NULL) SWIG_fail;
22683 temp3 = true;
22684 }
22685 }
22686 if (obj3) {
22687 {
22688 arg4 = wxString_in_helper(obj3);
22689 if (arg4 == NULL) SWIG_fail;
22690 temp4 = true;
22691 }
22692 }
22693 if (obj4) {
22694 ecode5 = SWIG_AsVal_long(obj4, &val5);
22695 if (!SWIG_IsOK(ecode5)) {
22696 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22697 }
22698 arg5 = static_cast< long >(val5);
22699 }
22700 {
22701 PyThreadState* __tstate = wxPyBeginAllowThreads();
22702 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22703 wxPyEndAllowThreads(__tstate);
22704 if (PyErr_Occurred()) SWIG_fail;
22705 }
22706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22707 {
22708 if (temp1)
22709 delete arg1;
22710 }
22711 {
22712 if (temp2)
22713 delete arg2;
22714 }
22715 {
22716 if (temp3)
22717 delete arg3;
22718 }
22719 {
22720 if (temp4)
22721 delete arg4;
22722 }
22723 return resultobj;
22724 fail:
22725 {
22726 if (temp1)
22727 delete arg1;
22728 }
22729 {
22730 if (temp2)
22731 delete arg2;
22732 }
22733 {
22734 if (temp3)
22735 delete arg3;
22736 }
22737 {
22738 if (temp4)
22739 delete arg4;
22740 }
22741 return NULL;
22742 }
22743
22744
22745 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22746 PyObject *resultobj = 0;
22747 wxConfig *arg1 = (wxConfig *) 0 ;
22748 void *argp1 = 0 ;
22749 int res1 = 0 ;
22750 PyObject *swig_obj[1] ;
22751
22752 if (!args) SWIG_fail;
22753 swig_obj[0] = args;
22754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22755 if (!SWIG_IsOK(res1)) {
22756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22757 }
22758 arg1 = reinterpret_cast< wxConfig * >(argp1);
22759 {
22760 PyThreadState* __tstate = wxPyBeginAllowThreads();
22761 delete arg1;
22762
22763 wxPyEndAllowThreads(__tstate);
22764 if (PyErr_Occurred()) SWIG_fail;
22765 }
22766 resultobj = SWIG_Py_Void();
22767 return resultobj;
22768 fail:
22769 return NULL;
22770 }
22771
22772
22773 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22774 PyObject *obj;
22775 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22776 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22777 return SWIG_Py_Void();
22778 }
22779
22780 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22781 return SWIG_Python_InitShadowInstance(args);
22782 }
22783
22784 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22785 PyObject *resultobj = 0;
22786 wxString const &arg1_defvalue = wxPyEmptyString ;
22787 wxString *arg1 = (wxString *) &arg1_defvalue ;
22788 wxString const &arg2_defvalue = wxPyEmptyString ;
22789 wxString *arg2 = (wxString *) &arg2_defvalue ;
22790 wxString const &arg3_defvalue = wxPyEmptyString ;
22791 wxString *arg3 = (wxString *) &arg3_defvalue ;
22792 wxString const &arg4_defvalue = wxPyEmptyString ;
22793 wxString *arg4 = (wxString *) &arg4_defvalue ;
22794 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22795 wxFileConfig *result = 0 ;
22796 bool temp1 = false ;
22797 bool temp2 = false ;
22798 bool temp3 = false ;
22799 bool temp4 = false ;
22800 long val5 ;
22801 int ecode5 = 0 ;
22802 PyObject * obj0 = 0 ;
22803 PyObject * obj1 = 0 ;
22804 PyObject * obj2 = 0 ;
22805 PyObject * obj3 = 0 ;
22806 PyObject * obj4 = 0 ;
22807 char * kwnames[] = {
22808 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22809 };
22810
22811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22812 if (obj0) {
22813 {
22814 arg1 = wxString_in_helper(obj0);
22815 if (arg1 == NULL) SWIG_fail;
22816 temp1 = true;
22817 }
22818 }
22819 if (obj1) {
22820 {
22821 arg2 = wxString_in_helper(obj1);
22822 if (arg2 == NULL) SWIG_fail;
22823 temp2 = true;
22824 }
22825 }
22826 if (obj2) {
22827 {
22828 arg3 = wxString_in_helper(obj2);
22829 if (arg3 == NULL) SWIG_fail;
22830 temp3 = true;
22831 }
22832 }
22833 if (obj3) {
22834 {
22835 arg4 = wxString_in_helper(obj3);
22836 if (arg4 == NULL) SWIG_fail;
22837 temp4 = true;
22838 }
22839 }
22840 if (obj4) {
22841 ecode5 = SWIG_AsVal_long(obj4, &val5);
22842 if (!SWIG_IsOK(ecode5)) {
22843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22844 }
22845 arg5 = static_cast< long >(val5);
22846 }
22847 {
22848 PyThreadState* __tstate = wxPyBeginAllowThreads();
22849 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22850 wxPyEndAllowThreads(__tstate);
22851 if (PyErr_Occurred()) SWIG_fail;
22852 }
22853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22854 {
22855 if (temp1)
22856 delete arg1;
22857 }
22858 {
22859 if (temp2)
22860 delete arg2;
22861 }
22862 {
22863 if (temp3)
22864 delete arg3;
22865 }
22866 {
22867 if (temp4)
22868 delete arg4;
22869 }
22870 return resultobj;
22871 fail:
22872 {
22873 if (temp1)
22874 delete arg1;
22875 }
22876 {
22877 if (temp2)
22878 delete arg2;
22879 }
22880 {
22881 if (temp3)
22882 delete arg3;
22883 }
22884 {
22885 if (temp4)
22886 delete arg4;
22887 }
22888 return NULL;
22889 }
22890
22891
22892 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22893 PyObject *resultobj = 0;
22894 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22895 void *argp1 = 0 ;
22896 int res1 = 0 ;
22897 PyObject *swig_obj[1] ;
22898
22899 if (!args) SWIG_fail;
22900 swig_obj[0] = args;
22901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22902 if (!SWIG_IsOK(res1)) {
22903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22904 }
22905 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22906 {
22907 PyThreadState* __tstate = wxPyBeginAllowThreads();
22908 delete arg1;
22909
22910 wxPyEndAllowThreads(__tstate);
22911 if (PyErr_Occurred()) SWIG_fail;
22912 }
22913 resultobj = SWIG_Py_Void();
22914 return resultobj;
22915 fail:
22916 return NULL;
22917 }
22918
22919
22920 SWIGINTERN PyObject *_wrap_FileConfig_GetGlobalFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22921 PyObject *resultobj = 0;
22922 wxString *arg1 = 0 ;
22923 wxString result;
22924 bool temp1 = false ;
22925 PyObject * obj0 = 0 ;
22926 char * kwnames[] = {
22927 (char *) "szFile", NULL
22928 };
22929
22930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileConfig_GetGlobalFileName",kwnames,&obj0)) SWIG_fail;
22931 {
22932 arg1 = wxString_in_helper(obj0);
22933 if (arg1 == NULL) SWIG_fail;
22934 temp1 = true;
22935 }
22936 {
22937 PyThreadState* __tstate = wxPyBeginAllowThreads();
22938 result = wxFileConfig::GetGlobalFileName((wxString const &)*arg1);
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 {
22943 #if wxUSE_UNICODE
22944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22945 #else
22946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22947 #endif
22948 }
22949 {
22950 if (temp1)
22951 delete arg1;
22952 }
22953 return resultobj;
22954 fail:
22955 {
22956 if (temp1)
22957 delete arg1;
22958 }
22959 return NULL;
22960 }
22961
22962
22963 SWIGINTERN PyObject *_wrap_FileConfig_GetLocalFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22964 PyObject *resultobj = 0;
22965 wxString *arg1 = 0 ;
22966 int arg2 = (int) 0 ;
22967 wxString result;
22968 bool temp1 = false ;
22969 int val2 ;
22970 int ecode2 = 0 ;
22971 PyObject * obj0 = 0 ;
22972 PyObject * obj1 = 0 ;
22973 char * kwnames[] = {
22974 (char *) "szFile",(char *) "style", NULL
22975 };
22976
22977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FileConfig_GetLocalFileName",kwnames,&obj0,&obj1)) SWIG_fail;
22978 {
22979 arg1 = wxString_in_helper(obj0);
22980 if (arg1 == NULL) SWIG_fail;
22981 temp1 = true;
22982 }
22983 if (obj1) {
22984 ecode2 = SWIG_AsVal_int(obj1, &val2);
22985 if (!SWIG_IsOK(ecode2)) {
22986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileConfig_GetLocalFileName" "', expected argument " "2"" of type '" "int""'");
22987 }
22988 arg2 = static_cast< int >(val2);
22989 }
22990 {
22991 PyThreadState* __tstate = wxPyBeginAllowThreads();
22992 result = wxFileConfig::GetLocalFileName((wxString const &)*arg1,arg2);
22993 wxPyEndAllowThreads(__tstate);
22994 if (PyErr_Occurred()) SWIG_fail;
22995 }
22996 {
22997 #if wxUSE_UNICODE
22998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22999 #else
23000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23001 #endif
23002 }
23003 {
23004 if (temp1)
23005 delete arg1;
23006 }
23007 return resultobj;
23008 fail:
23009 {
23010 if (temp1)
23011 delete arg1;
23012 }
23013 return NULL;
23014 }
23015
23016
23017 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23018 PyObject *obj;
23019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23020 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
23021 return SWIG_Py_Void();
23022 }
23023
23024 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23025 return SWIG_Python_InitShadowInstance(args);
23026 }
23027
23028 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23029 PyObject *resultobj = 0;
23030 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
23031 wxString *arg2 = 0 ;
23032 wxConfigPathChanger *result = 0 ;
23033 void *argp1 = 0 ;
23034 int res1 = 0 ;
23035 bool temp2 = false ;
23036 PyObject * obj0 = 0 ;
23037 PyObject * obj1 = 0 ;
23038 char * kwnames[] = {
23039 (char *) "config",(char *) "entry", NULL
23040 };
23041
23042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
23043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
23044 if (!SWIG_IsOK(res1)) {
23045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
23046 }
23047 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
23048 {
23049 arg2 = wxString_in_helper(obj1);
23050 if (arg2 == NULL) SWIG_fail;
23051 temp2 = true;
23052 }
23053 {
23054 PyThreadState* __tstate = wxPyBeginAllowThreads();
23055 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23056 wxPyEndAllowThreads(__tstate);
23057 if (PyErr_Occurred()) SWIG_fail;
23058 }
23059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23060 {
23061 if (temp2)
23062 delete arg2;
23063 }
23064 return resultobj;
23065 fail:
23066 {
23067 if (temp2)
23068 delete arg2;
23069 }
23070 return NULL;
23071 }
23072
23073
23074 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23075 PyObject *resultobj = 0;
23076 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23077 void *argp1 = 0 ;
23078 int res1 = 0 ;
23079 PyObject *swig_obj[1] ;
23080
23081 if (!args) SWIG_fail;
23082 swig_obj[0] = args;
23083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23084 if (!SWIG_IsOK(res1)) {
23085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23086 }
23087 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23088 {
23089 PyThreadState* __tstate = wxPyBeginAllowThreads();
23090 delete arg1;
23091
23092 wxPyEndAllowThreads(__tstate);
23093 if (PyErr_Occurred()) SWIG_fail;
23094 }
23095 resultobj = SWIG_Py_Void();
23096 return resultobj;
23097 fail:
23098 return NULL;
23099 }
23100
23101
23102 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23103 PyObject *resultobj = 0;
23104 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23105 wxString *result = 0 ;
23106 void *argp1 = 0 ;
23107 int res1 = 0 ;
23108 PyObject *swig_obj[1] ;
23109
23110 if (!args) SWIG_fail;
23111 swig_obj[0] = args;
23112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23113 if (!SWIG_IsOK(res1)) {
23114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23115 }
23116 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23117 {
23118 PyThreadState* __tstate = wxPyBeginAllowThreads();
23119 {
23120 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23121 result = (wxString *) &_result_ref;
23122 }
23123 wxPyEndAllowThreads(__tstate);
23124 if (PyErr_Occurred()) SWIG_fail;
23125 }
23126 {
23127 #if wxUSE_UNICODE
23128 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23129 #else
23130 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23131 #endif
23132 }
23133 return resultobj;
23134 fail:
23135 return NULL;
23136 }
23137
23138
23139 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23140 PyObject *obj;
23141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23142 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23143 return SWIG_Py_Void();
23144 }
23145
23146 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23147 return SWIG_Python_InitShadowInstance(args);
23148 }
23149
23150 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23151 PyObject *resultobj = 0;
23152 wxString *arg1 = 0 ;
23153 wxString result;
23154 bool temp1 = false ;
23155 PyObject * obj0 = 0 ;
23156 char * kwnames[] = {
23157 (char *) "sz", NULL
23158 };
23159
23160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23161 {
23162 arg1 = wxString_in_helper(obj0);
23163 if (arg1 == NULL) SWIG_fail;
23164 temp1 = true;
23165 }
23166 {
23167 PyThreadState* __tstate = wxPyBeginAllowThreads();
23168 result = wxExpandEnvVars((wxString const &)*arg1);
23169 wxPyEndAllowThreads(__tstate);
23170 if (PyErr_Occurred()) SWIG_fail;
23171 }
23172 {
23173 #if wxUSE_UNICODE
23174 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23175 #else
23176 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23177 #endif
23178 }
23179 {
23180 if (temp1)
23181 delete arg1;
23182 }
23183 return resultobj;
23184 fail:
23185 {
23186 if (temp1)
23187 delete arg1;
23188 }
23189 return NULL;
23190 }
23191
23192
23193 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23194 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23195 return 1;
23196 }
23197
23198
23199 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23200 PyObject *pyobj = 0;
23201
23202 {
23203 #if wxUSE_UNICODE
23204 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23205 #else
23206 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23207 #endif
23208 }
23209 return pyobj;
23210 }
23211
23212
23213 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23214 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23215 return 1;
23216 }
23217
23218
23219 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23220 PyObject *pyobj = 0;
23221
23222 {
23223 #if wxUSE_UNICODE
23224 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23225 #else
23226 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23227 #endif
23228 }
23229 return pyobj;
23230 }
23231
23232
23233 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23234 PyObject *resultobj = 0;
23235 wxDateTime::Country arg1 ;
23236 int val1 ;
23237 int ecode1 = 0 ;
23238 PyObject * obj0 = 0 ;
23239 char * kwnames[] = {
23240 (char *) "country", NULL
23241 };
23242
23243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23244 ecode1 = SWIG_AsVal_int(obj0, &val1);
23245 if (!SWIG_IsOK(ecode1)) {
23246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23247 }
23248 arg1 = static_cast< wxDateTime::Country >(val1);
23249 {
23250 PyThreadState* __tstate = wxPyBeginAllowThreads();
23251 wxDateTime::SetCountry(arg1);
23252 wxPyEndAllowThreads(__tstate);
23253 if (PyErr_Occurred()) SWIG_fail;
23254 }
23255 resultobj = SWIG_Py_Void();
23256 return resultobj;
23257 fail:
23258 return NULL;
23259 }
23260
23261
23262 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23263 PyObject *resultobj = 0;
23264 wxDateTime::Country result;
23265
23266 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23267 {
23268 PyThreadState* __tstate = wxPyBeginAllowThreads();
23269 result = (wxDateTime::Country)wxDateTime::GetCountry();
23270 wxPyEndAllowThreads(__tstate);
23271 if (PyErr_Occurred()) SWIG_fail;
23272 }
23273 resultobj = SWIG_From_int(static_cast< int >(result));
23274 return resultobj;
23275 fail:
23276 return NULL;
23277 }
23278
23279
23280 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23281 PyObject *resultobj = 0;
23282 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23283 bool result;
23284 int val1 ;
23285 int ecode1 = 0 ;
23286 PyObject * obj0 = 0 ;
23287 char * kwnames[] = {
23288 (char *) "country", NULL
23289 };
23290
23291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23292 if (obj0) {
23293 ecode1 = SWIG_AsVal_int(obj0, &val1);
23294 if (!SWIG_IsOK(ecode1)) {
23295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23296 }
23297 arg1 = static_cast< wxDateTime::Country >(val1);
23298 }
23299 {
23300 PyThreadState* __tstate = wxPyBeginAllowThreads();
23301 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23302 wxPyEndAllowThreads(__tstate);
23303 if (PyErr_Occurred()) SWIG_fail;
23304 }
23305 {
23306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23307 }
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23315 PyObject *resultobj = 0;
23316 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23317 int result;
23318 int val1 ;
23319 int ecode1 = 0 ;
23320 PyObject * obj0 = 0 ;
23321 char * kwnames[] = {
23322 (char *) "cal", NULL
23323 };
23324
23325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23326 if (obj0) {
23327 ecode1 = SWIG_AsVal_int(obj0, &val1);
23328 if (!SWIG_IsOK(ecode1)) {
23329 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23330 }
23331 arg1 = static_cast< wxDateTime::Calendar >(val1);
23332 }
23333 {
23334 PyThreadState* __tstate = wxPyBeginAllowThreads();
23335 result = (int)wxDateTime::GetCurrentYear(arg1);
23336 wxPyEndAllowThreads(__tstate);
23337 if (PyErr_Occurred()) SWIG_fail;
23338 }
23339 resultobj = SWIG_From_int(static_cast< int >(result));
23340 return resultobj;
23341 fail:
23342 return NULL;
23343 }
23344
23345
23346 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23347 PyObject *resultobj = 0;
23348 int arg1 ;
23349 int result;
23350 int val1 ;
23351 int ecode1 = 0 ;
23352 PyObject * obj0 = 0 ;
23353 char * kwnames[] = {
23354 (char *) "year", NULL
23355 };
23356
23357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23358 ecode1 = SWIG_AsVal_int(obj0, &val1);
23359 if (!SWIG_IsOK(ecode1)) {
23360 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23361 }
23362 arg1 = static_cast< int >(val1);
23363 {
23364 PyThreadState* __tstate = wxPyBeginAllowThreads();
23365 result = (int)wxDateTime::ConvertYearToBC(arg1);
23366 wxPyEndAllowThreads(__tstate);
23367 if (PyErr_Occurred()) SWIG_fail;
23368 }
23369 resultobj = SWIG_From_int(static_cast< int >(result));
23370 return resultobj;
23371 fail:
23372 return NULL;
23373 }
23374
23375
23376 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23377 PyObject *resultobj = 0;
23378 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23379 wxDateTime::Month result;
23380 int val1 ;
23381 int ecode1 = 0 ;
23382 PyObject * obj0 = 0 ;
23383 char * kwnames[] = {
23384 (char *) "cal", NULL
23385 };
23386
23387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23388 if (obj0) {
23389 ecode1 = SWIG_AsVal_int(obj0, &val1);
23390 if (!SWIG_IsOK(ecode1)) {
23391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23392 }
23393 arg1 = static_cast< wxDateTime::Calendar >(val1);
23394 }
23395 {
23396 PyThreadState* __tstate = wxPyBeginAllowThreads();
23397 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23398 wxPyEndAllowThreads(__tstate);
23399 if (PyErr_Occurred()) SWIG_fail;
23400 }
23401 resultobj = SWIG_From_int(static_cast< int >(result));
23402 return resultobj;
23403 fail:
23404 return NULL;
23405 }
23406
23407
23408 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23409 PyObject *resultobj = 0;
23410 int arg1 = (int) wxDateTime::Inv_Year ;
23411 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23412 bool result;
23413 int val1 ;
23414 int ecode1 = 0 ;
23415 int val2 ;
23416 int ecode2 = 0 ;
23417 PyObject * obj0 = 0 ;
23418 PyObject * obj1 = 0 ;
23419 char * kwnames[] = {
23420 (char *) "year",(char *) "cal", NULL
23421 };
23422
23423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23424 if (obj0) {
23425 ecode1 = SWIG_AsVal_int(obj0, &val1);
23426 if (!SWIG_IsOK(ecode1)) {
23427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23428 }
23429 arg1 = static_cast< int >(val1);
23430 }
23431 if (obj1) {
23432 ecode2 = SWIG_AsVal_int(obj1, &val2);
23433 if (!SWIG_IsOK(ecode2)) {
23434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23435 }
23436 arg2 = static_cast< wxDateTime::Calendar >(val2);
23437 }
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23441 wxPyEndAllowThreads(__tstate);
23442 if (PyErr_Occurred()) SWIG_fail;
23443 }
23444 {
23445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23446 }
23447 return resultobj;
23448 fail:
23449 return NULL;
23450 }
23451
23452
23453 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23454 PyObject *resultobj = 0;
23455 int arg1 = (int) wxDateTime::Inv_Year ;
23456 int result;
23457 int val1 ;
23458 int ecode1 = 0 ;
23459 PyObject * obj0 = 0 ;
23460 char * kwnames[] = {
23461 (char *) "year", NULL
23462 };
23463
23464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23465 if (obj0) {
23466 ecode1 = SWIG_AsVal_int(obj0, &val1);
23467 if (!SWIG_IsOK(ecode1)) {
23468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23469 }
23470 arg1 = static_cast< int >(val1);
23471 }
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = (int)wxDateTime::GetCentury(arg1);
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 resultobj = SWIG_From_int(static_cast< int >(result));
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj = 0;
23487 int arg1 ;
23488 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23489 int result;
23490 int val1 ;
23491 int ecode1 = 0 ;
23492 int val2 ;
23493 int ecode2 = 0 ;
23494 PyObject * obj0 = 0 ;
23495 PyObject * obj1 = 0 ;
23496 char * kwnames[] = {
23497 (char *) "year",(char *) "cal", NULL
23498 };
23499
23500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23501 ecode1 = SWIG_AsVal_int(obj0, &val1);
23502 if (!SWIG_IsOK(ecode1)) {
23503 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23504 }
23505 arg1 = static_cast< int >(val1);
23506 if (obj1) {
23507 ecode2 = SWIG_AsVal_int(obj1, &val2);
23508 if (!SWIG_IsOK(ecode2)) {
23509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23510 }
23511 arg2 = static_cast< wxDateTime::Calendar >(val2);
23512 }
23513 {
23514 PyThreadState* __tstate = wxPyBeginAllowThreads();
23515 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23516 wxPyEndAllowThreads(__tstate);
23517 if (PyErr_Occurred()) SWIG_fail;
23518 }
23519 resultobj = SWIG_From_int(static_cast< int >(result));
23520 return resultobj;
23521 fail:
23522 return NULL;
23523 }
23524
23525
23526 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23527 PyObject *resultobj = 0;
23528 wxDateTime::Month arg1 ;
23529 int arg2 = (int) wxDateTime::Inv_Year ;
23530 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23531 int result;
23532 int val1 ;
23533 int ecode1 = 0 ;
23534 int val2 ;
23535 int ecode2 = 0 ;
23536 int val3 ;
23537 int ecode3 = 0 ;
23538 PyObject * obj0 = 0 ;
23539 PyObject * obj1 = 0 ;
23540 PyObject * obj2 = 0 ;
23541 char * kwnames[] = {
23542 (char *) "month",(char *) "year",(char *) "cal", NULL
23543 };
23544
23545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23546 ecode1 = SWIG_AsVal_int(obj0, &val1);
23547 if (!SWIG_IsOK(ecode1)) {
23548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23549 }
23550 arg1 = static_cast< wxDateTime::Month >(val1);
23551 if (obj1) {
23552 ecode2 = SWIG_AsVal_int(obj1, &val2);
23553 if (!SWIG_IsOK(ecode2)) {
23554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23555 }
23556 arg2 = static_cast< int >(val2);
23557 }
23558 if (obj2) {
23559 ecode3 = SWIG_AsVal_int(obj2, &val3);
23560 if (!SWIG_IsOK(ecode3)) {
23561 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23562 }
23563 arg3 = static_cast< wxDateTime::Calendar >(val3);
23564 }
23565 {
23566 PyThreadState* __tstate = wxPyBeginAllowThreads();
23567 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23568 wxPyEndAllowThreads(__tstate);
23569 if (PyErr_Occurred()) SWIG_fail;
23570 }
23571 resultobj = SWIG_From_int(static_cast< int >(result));
23572 return resultobj;
23573 fail:
23574 return NULL;
23575 }
23576
23577
23578 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23579 PyObject *resultobj = 0;
23580 wxDateTime::Month arg1 ;
23581 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23582 wxString result;
23583 int val1 ;
23584 int ecode1 = 0 ;
23585 int val2 ;
23586 int ecode2 = 0 ;
23587 PyObject * obj0 = 0 ;
23588 PyObject * obj1 = 0 ;
23589 char * kwnames[] = {
23590 (char *) "month",(char *) "flags", NULL
23591 };
23592
23593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23594 ecode1 = SWIG_AsVal_int(obj0, &val1);
23595 if (!SWIG_IsOK(ecode1)) {
23596 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23597 }
23598 arg1 = static_cast< wxDateTime::Month >(val1);
23599 if (obj1) {
23600 ecode2 = SWIG_AsVal_int(obj1, &val2);
23601 if (!SWIG_IsOK(ecode2)) {
23602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23603 }
23604 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23605 }
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = wxDateTime::GetMonthName(arg1,arg2);
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 {
23613 #if wxUSE_UNICODE
23614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23615 #else
23616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23617 #endif
23618 }
23619 return resultobj;
23620 fail:
23621 return NULL;
23622 }
23623
23624
23625 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23626 PyObject *resultobj = 0;
23627 wxDateTime::WeekDay arg1 ;
23628 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23629 wxString result;
23630 int val1 ;
23631 int ecode1 = 0 ;
23632 int val2 ;
23633 int ecode2 = 0 ;
23634 PyObject * obj0 = 0 ;
23635 PyObject * obj1 = 0 ;
23636 char * kwnames[] = {
23637 (char *) "weekday",(char *) "flags", NULL
23638 };
23639
23640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23641 ecode1 = SWIG_AsVal_int(obj0, &val1);
23642 if (!SWIG_IsOK(ecode1)) {
23643 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23644 }
23645 arg1 = static_cast< wxDateTime::WeekDay >(val1);
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_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23650 }
23651 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23652 }
23653 {
23654 PyThreadState* __tstate = wxPyBeginAllowThreads();
23655 result = wxDateTime::GetWeekDayName(arg1,arg2);
23656 wxPyEndAllowThreads(__tstate);
23657 if (PyErr_Occurred()) SWIG_fail;
23658 }
23659 {
23660 #if wxUSE_UNICODE
23661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23662 #else
23663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23664 #endif
23665 }
23666 return resultobj;
23667 fail:
23668 return NULL;
23669 }
23670
23671
23672 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23673 PyObject *resultobj = 0;
23674 PyObject *result = 0 ;
23675
23676 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23677 {
23678 PyThreadState* __tstate = wxPyBeginAllowThreads();
23679 result = (PyObject *)wxDateTime_GetAmPmStrings();
23680 wxPyEndAllowThreads(__tstate);
23681 if (PyErr_Occurred()) SWIG_fail;
23682 }
23683 resultobj = result;
23684 return resultobj;
23685 fail:
23686 return NULL;
23687 }
23688
23689
23690 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23691 PyObject *resultobj = 0;
23692 int arg1 = (int) wxDateTime::Inv_Year ;
23693 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23694 bool result;
23695 int val1 ;
23696 int ecode1 = 0 ;
23697 int val2 ;
23698 int ecode2 = 0 ;
23699 PyObject * obj0 = 0 ;
23700 PyObject * obj1 = 0 ;
23701 char * kwnames[] = {
23702 (char *) "year",(char *) "country", NULL
23703 };
23704
23705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23706 if (obj0) {
23707 ecode1 = SWIG_AsVal_int(obj0, &val1);
23708 if (!SWIG_IsOK(ecode1)) {
23709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23710 }
23711 arg1 = static_cast< int >(val1);
23712 }
23713 if (obj1) {
23714 ecode2 = SWIG_AsVal_int(obj1, &val2);
23715 if (!SWIG_IsOK(ecode2)) {
23716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23717 }
23718 arg2 = static_cast< wxDateTime::Country >(val2);
23719 }
23720 {
23721 PyThreadState* __tstate = wxPyBeginAllowThreads();
23722 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 {
23727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23728 }
23729 return resultobj;
23730 fail:
23731 return NULL;
23732 }
23733
23734
23735 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23736 PyObject *resultobj = 0;
23737 int arg1 = (int) wxDateTime::Inv_Year ;
23738 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23739 wxDateTime result;
23740 int val1 ;
23741 int ecode1 = 0 ;
23742 int val2 ;
23743 int ecode2 = 0 ;
23744 PyObject * obj0 = 0 ;
23745 PyObject * obj1 = 0 ;
23746 char * kwnames[] = {
23747 (char *) "year",(char *) "country", NULL
23748 };
23749
23750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23751 if (obj0) {
23752 ecode1 = SWIG_AsVal_int(obj0, &val1);
23753 if (!SWIG_IsOK(ecode1)) {
23754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23755 }
23756 arg1 = static_cast< int >(val1);
23757 }
23758 if (obj1) {
23759 ecode2 = SWIG_AsVal_int(obj1, &val2);
23760 if (!SWIG_IsOK(ecode2)) {
23761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23762 }
23763 arg2 = static_cast< wxDateTime::Country >(val2);
23764 }
23765 {
23766 PyThreadState* __tstate = wxPyBeginAllowThreads();
23767 result = wxDateTime::GetBeginDST(arg1,arg2);
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23772 return resultobj;
23773 fail:
23774 return NULL;
23775 }
23776
23777
23778 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23779 PyObject *resultobj = 0;
23780 int arg1 = (int) wxDateTime::Inv_Year ;
23781 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23782 wxDateTime result;
23783 int val1 ;
23784 int ecode1 = 0 ;
23785 int val2 ;
23786 int ecode2 = 0 ;
23787 PyObject * obj0 = 0 ;
23788 PyObject * obj1 = 0 ;
23789 char * kwnames[] = {
23790 (char *) "year",(char *) "country", NULL
23791 };
23792
23793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23794 if (obj0) {
23795 ecode1 = SWIG_AsVal_int(obj0, &val1);
23796 if (!SWIG_IsOK(ecode1)) {
23797 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23798 }
23799 arg1 = static_cast< int >(val1);
23800 }
23801 if (obj1) {
23802 ecode2 = SWIG_AsVal_int(obj1, &val2);
23803 if (!SWIG_IsOK(ecode2)) {
23804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23805 }
23806 arg2 = static_cast< wxDateTime::Country >(val2);
23807 }
23808 {
23809 PyThreadState* __tstate = wxPyBeginAllowThreads();
23810 result = wxDateTime::GetEndDST(arg1,arg2);
23811 wxPyEndAllowThreads(__tstate);
23812 if (PyErr_Occurred()) SWIG_fail;
23813 }
23814 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23815 return resultobj;
23816 fail:
23817 return NULL;
23818 }
23819
23820
23821 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23822 PyObject *resultobj = 0;
23823 wxDateTime result;
23824
23825 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = wxDateTime::Now();
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23840 PyObject *resultobj = 0;
23841 wxDateTime result;
23842
23843 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23844 {
23845 PyThreadState* __tstate = wxPyBeginAllowThreads();
23846 result = wxDateTime::UNow();
23847 wxPyEndAllowThreads(__tstate);
23848 if (PyErr_Occurred()) SWIG_fail;
23849 }
23850 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23851 return resultobj;
23852 fail:
23853 return NULL;
23854 }
23855
23856
23857 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23858 PyObject *resultobj = 0;
23859 wxDateTime result;
23860
23861 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23862 {
23863 PyThreadState* __tstate = wxPyBeginAllowThreads();
23864 result = wxDateTime::Today();
23865 wxPyEndAllowThreads(__tstate);
23866 if (PyErr_Occurred()) SWIG_fail;
23867 }
23868 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23869 return resultobj;
23870 fail:
23871 return NULL;
23872 }
23873
23874
23875 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23876 PyObject *resultobj = 0;
23877 wxDateTime *result = 0 ;
23878
23879 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23880 {
23881 PyThreadState* __tstate = wxPyBeginAllowThreads();
23882 result = (wxDateTime *)new wxDateTime();
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23894 PyObject *resultobj = 0;
23895 time_t arg1 ;
23896 wxDateTime *result = 0 ;
23897 unsigned int val1 ;
23898 int ecode1 = 0 ;
23899 PyObject * obj0 = 0 ;
23900 char * kwnames[] = {
23901 (char *) "timet", NULL
23902 };
23903
23904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23905 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23906 if (!SWIG_IsOK(ecode1)) {
23907 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23908 }
23909 arg1 = static_cast< time_t >(val1);
23910 {
23911 PyThreadState* __tstate = wxPyBeginAllowThreads();
23912 result = (wxDateTime *)new wxDateTime(arg1);
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23917 return resultobj;
23918 fail:
23919 return NULL;
23920 }
23921
23922
23923 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23924 PyObject *resultobj = 0;
23925 double arg1 ;
23926 wxDateTime *result = 0 ;
23927 double val1 ;
23928 int ecode1 = 0 ;
23929 PyObject * obj0 = 0 ;
23930 char * kwnames[] = {
23931 (char *) "jdn", NULL
23932 };
23933
23934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23935 ecode1 = SWIG_AsVal_double(obj0, &val1);
23936 if (!SWIG_IsOK(ecode1)) {
23937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23938 }
23939 arg1 = static_cast< double >(val1);
23940 {
23941 PyThreadState* __tstate = wxPyBeginAllowThreads();
23942 result = (wxDateTime *)new wxDateTime(arg1);
23943 wxPyEndAllowThreads(__tstate);
23944 if (PyErr_Occurred()) SWIG_fail;
23945 }
23946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23947 return resultobj;
23948 fail:
23949 return NULL;
23950 }
23951
23952
23953 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23954 PyObject *resultobj = 0;
23955 int arg1 ;
23956 int arg2 = (int) 0 ;
23957 int arg3 = (int) 0 ;
23958 int arg4 = (int) 0 ;
23959 wxDateTime *result = 0 ;
23960 int val1 ;
23961 int ecode1 = 0 ;
23962 int val2 ;
23963 int ecode2 = 0 ;
23964 int val3 ;
23965 int ecode3 = 0 ;
23966 int val4 ;
23967 int ecode4 = 0 ;
23968 PyObject * obj0 = 0 ;
23969 PyObject * obj1 = 0 ;
23970 PyObject * obj2 = 0 ;
23971 PyObject * obj3 = 0 ;
23972 char * kwnames[] = {
23973 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23974 };
23975
23976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23977 ecode1 = SWIG_AsVal_int(obj0, &val1);
23978 if (!SWIG_IsOK(ecode1)) {
23979 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23980 }
23981 arg1 = static_cast< int >(val1);
23982 if (obj1) {
23983 ecode2 = SWIG_AsVal_int(obj1, &val2);
23984 if (!SWIG_IsOK(ecode2)) {
23985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23986 }
23987 arg2 = static_cast< int >(val2);
23988 }
23989 if (obj2) {
23990 ecode3 = SWIG_AsVal_int(obj2, &val3);
23991 if (!SWIG_IsOK(ecode3)) {
23992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23993 }
23994 arg3 = static_cast< int >(val3);
23995 }
23996 if (obj3) {
23997 ecode4 = SWIG_AsVal_int(obj3, &val4);
23998 if (!SWIG_IsOK(ecode4)) {
23999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
24000 }
24001 arg4 = static_cast< int >(val4);
24002 }
24003 {
24004 PyThreadState* __tstate = wxPyBeginAllowThreads();
24005 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
24006 wxPyEndAllowThreads(__tstate);
24007 if (PyErr_Occurred()) SWIG_fail;
24008 }
24009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24010 return resultobj;
24011 fail:
24012 return NULL;
24013 }
24014
24015
24016 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24017 PyObject *resultobj = 0;
24018 int arg1 ;
24019 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24020 int arg3 = (int) wxDateTime::Inv_Year ;
24021 int arg4 = (int) 0 ;
24022 int arg5 = (int) 0 ;
24023 int arg6 = (int) 0 ;
24024 int arg7 = (int) 0 ;
24025 wxDateTime *result = 0 ;
24026 int val1 ;
24027 int ecode1 = 0 ;
24028 int val2 ;
24029 int ecode2 = 0 ;
24030 int val3 ;
24031 int ecode3 = 0 ;
24032 int val4 ;
24033 int ecode4 = 0 ;
24034 int val5 ;
24035 int ecode5 = 0 ;
24036 int val6 ;
24037 int ecode6 = 0 ;
24038 int val7 ;
24039 int ecode7 = 0 ;
24040 PyObject * obj0 = 0 ;
24041 PyObject * obj1 = 0 ;
24042 PyObject * obj2 = 0 ;
24043 PyObject * obj3 = 0 ;
24044 PyObject * obj4 = 0 ;
24045 PyObject * obj5 = 0 ;
24046 PyObject * obj6 = 0 ;
24047 char * kwnames[] = {
24048 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24049 };
24050
24051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24052 ecode1 = SWIG_AsVal_int(obj0, &val1);
24053 if (!SWIG_IsOK(ecode1)) {
24054 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24055 }
24056 arg1 = static_cast< int >(val1);
24057 if (obj1) {
24058 ecode2 = SWIG_AsVal_int(obj1, &val2);
24059 if (!SWIG_IsOK(ecode2)) {
24060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24061 }
24062 arg2 = static_cast< wxDateTime::Month >(val2);
24063 }
24064 if (obj2) {
24065 ecode3 = SWIG_AsVal_int(obj2, &val3);
24066 if (!SWIG_IsOK(ecode3)) {
24067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24068 }
24069 arg3 = static_cast< int >(val3);
24070 }
24071 if (obj3) {
24072 ecode4 = SWIG_AsVal_int(obj3, &val4);
24073 if (!SWIG_IsOK(ecode4)) {
24074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24075 }
24076 arg4 = static_cast< int >(val4);
24077 }
24078 if (obj4) {
24079 ecode5 = SWIG_AsVal_int(obj4, &val5);
24080 if (!SWIG_IsOK(ecode5)) {
24081 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24082 }
24083 arg5 = static_cast< int >(val5);
24084 }
24085 if (obj5) {
24086 ecode6 = SWIG_AsVal_int(obj5, &val6);
24087 if (!SWIG_IsOK(ecode6)) {
24088 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24089 }
24090 arg6 = static_cast< int >(val6);
24091 }
24092 if (obj6) {
24093 ecode7 = SWIG_AsVal_int(obj6, &val7);
24094 if (!SWIG_IsOK(ecode7)) {
24095 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24096 }
24097 arg7 = static_cast< int >(val7);
24098 }
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24102 wxPyEndAllowThreads(__tstate);
24103 if (PyErr_Occurred()) SWIG_fail;
24104 }
24105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24113 PyObject *resultobj = 0;
24114 wxDateTime *arg1 = 0 ;
24115 wxDateTime *result = 0 ;
24116 void *argp1 = 0 ;
24117 int res1 = 0 ;
24118 PyObject * obj0 = 0 ;
24119 char * kwnames[] = {
24120 (char *) "date", NULL
24121 };
24122
24123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24124 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24125 if (!SWIG_IsOK(res1)) {
24126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24127 }
24128 if (!argp1) {
24129 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24130 }
24131 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24132 {
24133 PyThreadState* __tstate = wxPyBeginAllowThreads();
24134 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24135 wxPyEndAllowThreads(__tstate);
24136 if (PyErr_Occurred()) SWIG_fail;
24137 }
24138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24146 PyObject *resultobj = 0;
24147 wxDateTime *arg1 = (wxDateTime *) 0 ;
24148 void *argp1 = 0 ;
24149 int res1 = 0 ;
24150 PyObject *swig_obj[1] ;
24151
24152 if (!args) SWIG_fail;
24153 swig_obj[0] = args;
24154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24155 if (!SWIG_IsOK(res1)) {
24156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24157 }
24158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24159 {
24160 PyThreadState* __tstate = wxPyBeginAllowThreads();
24161 delete arg1;
24162
24163 wxPyEndAllowThreads(__tstate);
24164 if (PyErr_Occurred()) SWIG_fail;
24165 }
24166 resultobj = SWIG_Py_Void();
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24174 PyObject *resultobj = 0;
24175 wxDateTime *arg1 = (wxDateTime *) 0 ;
24176 wxDateTime *result = 0 ;
24177 void *argp1 = 0 ;
24178 int res1 = 0 ;
24179 PyObject *swig_obj[1] ;
24180
24181 if (!args) SWIG_fail;
24182 swig_obj[0] = args;
24183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24184 if (!SWIG_IsOK(res1)) {
24185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24186 }
24187 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24188 {
24189 PyThreadState* __tstate = wxPyBeginAllowThreads();
24190 {
24191 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24192 result = (wxDateTime *) &_result_ref;
24193 }
24194 wxPyEndAllowThreads(__tstate);
24195 if (PyErr_Occurred()) SWIG_fail;
24196 }
24197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24198 return resultobj;
24199 fail:
24200 return NULL;
24201 }
24202
24203
24204 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24205 PyObject *resultobj = 0;
24206 wxDateTime *arg1 = (wxDateTime *) 0 ;
24207 time_t arg2 ;
24208 wxDateTime *result = 0 ;
24209 void *argp1 = 0 ;
24210 int res1 = 0 ;
24211 unsigned int val2 ;
24212 int ecode2 = 0 ;
24213 PyObject * obj0 = 0 ;
24214 PyObject * obj1 = 0 ;
24215 char * kwnames[] = {
24216 (char *) "self",(char *) "timet", NULL
24217 };
24218
24219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24221 if (!SWIG_IsOK(res1)) {
24222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24223 }
24224 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24225 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24226 if (!SWIG_IsOK(ecode2)) {
24227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24228 }
24229 arg2 = static_cast< time_t >(val2);
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 {
24233 wxDateTime &_result_ref = (arg1)->Set(arg2);
24234 result = (wxDateTime *) &_result_ref;
24235 }
24236 wxPyEndAllowThreads(__tstate);
24237 if (PyErr_Occurred()) SWIG_fail;
24238 }
24239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24240 return resultobj;
24241 fail:
24242 return NULL;
24243 }
24244
24245
24246 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24247 PyObject *resultobj = 0;
24248 wxDateTime *arg1 = (wxDateTime *) 0 ;
24249 double arg2 ;
24250 wxDateTime *result = 0 ;
24251 void *argp1 = 0 ;
24252 int res1 = 0 ;
24253 double val2 ;
24254 int ecode2 = 0 ;
24255 PyObject * obj0 = 0 ;
24256 PyObject * obj1 = 0 ;
24257 char * kwnames[] = {
24258 (char *) "self",(char *) "jdn", NULL
24259 };
24260
24261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24263 if (!SWIG_IsOK(res1)) {
24264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24265 }
24266 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24267 ecode2 = SWIG_AsVal_double(obj1, &val2);
24268 if (!SWIG_IsOK(ecode2)) {
24269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24270 }
24271 arg2 = static_cast< double >(val2);
24272 {
24273 PyThreadState* __tstate = wxPyBeginAllowThreads();
24274 {
24275 wxDateTime &_result_ref = (arg1)->Set(arg2);
24276 result = (wxDateTime *) &_result_ref;
24277 }
24278 wxPyEndAllowThreads(__tstate);
24279 if (PyErr_Occurred()) SWIG_fail;
24280 }
24281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24282 return resultobj;
24283 fail:
24284 return NULL;
24285 }
24286
24287
24288 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24289 PyObject *resultobj = 0;
24290 wxDateTime *arg1 = (wxDateTime *) 0 ;
24291 int arg2 ;
24292 int arg3 = (int) 0 ;
24293 int arg4 = (int) 0 ;
24294 int arg5 = (int) 0 ;
24295 wxDateTime *result = 0 ;
24296 void *argp1 = 0 ;
24297 int res1 = 0 ;
24298 int val2 ;
24299 int ecode2 = 0 ;
24300 int val3 ;
24301 int ecode3 = 0 ;
24302 int val4 ;
24303 int ecode4 = 0 ;
24304 int val5 ;
24305 int ecode5 = 0 ;
24306 PyObject * obj0 = 0 ;
24307 PyObject * obj1 = 0 ;
24308 PyObject * obj2 = 0 ;
24309 PyObject * obj3 = 0 ;
24310 PyObject * obj4 = 0 ;
24311 char * kwnames[] = {
24312 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24313 };
24314
24315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24317 if (!SWIG_IsOK(res1)) {
24318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24319 }
24320 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24321 ecode2 = SWIG_AsVal_int(obj1, &val2);
24322 if (!SWIG_IsOK(ecode2)) {
24323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24324 }
24325 arg2 = static_cast< int >(val2);
24326 if (obj2) {
24327 ecode3 = SWIG_AsVal_int(obj2, &val3);
24328 if (!SWIG_IsOK(ecode3)) {
24329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24330 }
24331 arg3 = static_cast< int >(val3);
24332 }
24333 if (obj3) {
24334 ecode4 = SWIG_AsVal_int(obj3, &val4);
24335 if (!SWIG_IsOK(ecode4)) {
24336 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24337 }
24338 arg4 = static_cast< int >(val4);
24339 }
24340 if (obj4) {
24341 ecode5 = SWIG_AsVal_int(obj4, &val5);
24342 if (!SWIG_IsOK(ecode5)) {
24343 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24344 }
24345 arg5 = static_cast< int >(val5);
24346 }
24347 {
24348 PyThreadState* __tstate = wxPyBeginAllowThreads();
24349 {
24350 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24351 result = (wxDateTime *) &_result_ref;
24352 }
24353 wxPyEndAllowThreads(__tstate);
24354 if (PyErr_Occurred()) SWIG_fail;
24355 }
24356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24364 PyObject *resultobj = 0;
24365 wxDateTime *arg1 = (wxDateTime *) 0 ;
24366 int arg2 ;
24367 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24368 int arg4 = (int) wxDateTime::Inv_Year ;
24369 int arg5 = (int) 0 ;
24370 int arg6 = (int) 0 ;
24371 int arg7 = (int) 0 ;
24372 int arg8 = (int) 0 ;
24373 wxDateTime *result = 0 ;
24374 void *argp1 = 0 ;
24375 int res1 = 0 ;
24376 int val2 ;
24377 int ecode2 = 0 ;
24378 int val3 ;
24379 int ecode3 = 0 ;
24380 int val4 ;
24381 int ecode4 = 0 ;
24382 int val5 ;
24383 int ecode5 = 0 ;
24384 int val6 ;
24385 int ecode6 = 0 ;
24386 int val7 ;
24387 int ecode7 = 0 ;
24388 int val8 ;
24389 int ecode8 = 0 ;
24390 PyObject * obj0 = 0 ;
24391 PyObject * obj1 = 0 ;
24392 PyObject * obj2 = 0 ;
24393 PyObject * obj3 = 0 ;
24394 PyObject * obj4 = 0 ;
24395 PyObject * obj5 = 0 ;
24396 PyObject * obj6 = 0 ;
24397 PyObject * obj7 = 0 ;
24398 char * kwnames[] = {
24399 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24400 };
24401
24402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24404 if (!SWIG_IsOK(res1)) {
24405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24406 }
24407 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24408 ecode2 = SWIG_AsVal_int(obj1, &val2);
24409 if (!SWIG_IsOK(ecode2)) {
24410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24411 }
24412 arg2 = static_cast< int >(val2);
24413 if (obj2) {
24414 ecode3 = SWIG_AsVal_int(obj2, &val3);
24415 if (!SWIG_IsOK(ecode3)) {
24416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24417 }
24418 arg3 = static_cast< wxDateTime::Month >(val3);
24419 }
24420 if (obj3) {
24421 ecode4 = SWIG_AsVal_int(obj3, &val4);
24422 if (!SWIG_IsOK(ecode4)) {
24423 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24424 }
24425 arg4 = static_cast< int >(val4);
24426 }
24427 if (obj4) {
24428 ecode5 = SWIG_AsVal_int(obj4, &val5);
24429 if (!SWIG_IsOK(ecode5)) {
24430 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24431 }
24432 arg5 = static_cast< int >(val5);
24433 }
24434 if (obj5) {
24435 ecode6 = SWIG_AsVal_int(obj5, &val6);
24436 if (!SWIG_IsOK(ecode6)) {
24437 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24438 }
24439 arg6 = static_cast< int >(val6);
24440 }
24441 if (obj6) {
24442 ecode7 = SWIG_AsVal_int(obj6, &val7);
24443 if (!SWIG_IsOK(ecode7)) {
24444 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24445 }
24446 arg7 = static_cast< int >(val7);
24447 }
24448 if (obj7) {
24449 ecode8 = SWIG_AsVal_int(obj7, &val8);
24450 if (!SWIG_IsOK(ecode8)) {
24451 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24452 }
24453 arg8 = static_cast< int >(val8);
24454 }
24455 {
24456 PyThreadState* __tstate = wxPyBeginAllowThreads();
24457 {
24458 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24459 result = (wxDateTime *) &_result_ref;
24460 }
24461 wxPyEndAllowThreads(__tstate);
24462 if (PyErr_Occurred()) SWIG_fail;
24463 }
24464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24472 PyObject *resultobj = 0;
24473 wxDateTime *arg1 = (wxDateTime *) 0 ;
24474 wxDateTime *result = 0 ;
24475 void *argp1 = 0 ;
24476 int res1 = 0 ;
24477 PyObject *swig_obj[1] ;
24478
24479 if (!args) SWIG_fail;
24480 swig_obj[0] = args;
24481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24482 if (!SWIG_IsOK(res1)) {
24483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24484 }
24485 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24486 {
24487 PyThreadState* __tstate = wxPyBeginAllowThreads();
24488 {
24489 wxDateTime &_result_ref = (arg1)->ResetTime();
24490 result = (wxDateTime *) &_result_ref;
24491 }
24492 wxPyEndAllowThreads(__tstate);
24493 if (PyErr_Occurred()) SWIG_fail;
24494 }
24495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24496 return resultobj;
24497 fail:
24498 return NULL;
24499 }
24500
24501
24502 SWIGINTERN PyObject *_wrap_DateTime_GetDateOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24503 PyObject *resultobj = 0;
24504 wxDateTime *arg1 = (wxDateTime *) 0 ;
24505 wxDateTime result;
24506 void *argp1 = 0 ;
24507 int res1 = 0 ;
24508 PyObject *swig_obj[1] ;
24509
24510 if (!args) SWIG_fail;
24511 swig_obj[0] = args;
24512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24513 if (!SWIG_IsOK(res1)) {
24514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDateOnly" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24515 }
24516 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24517 {
24518 PyThreadState* __tstate = wxPyBeginAllowThreads();
24519 result = ((wxDateTime const *)arg1)->GetDateOnly();
24520 wxPyEndAllowThreads(__tstate);
24521 if (PyErr_Occurred()) SWIG_fail;
24522 }
24523 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24524 return resultobj;
24525 fail:
24526 return NULL;
24527 }
24528
24529
24530 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24531 PyObject *resultobj = 0;
24532 wxDateTime *arg1 = (wxDateTime *) 0 ;
24533 int arg2 ;
24534 wxDateTime *result = 0 ;
24535 void *argp1 = 0 ;
24536 int res1 = 0 ;
24537 int val2 ;
24538 int ecode2 = 0 ;
24539 PyObject * obj0 = 0 ;
24540 PyObject * obj1 = 0 ;
24541 char * kwnames[] = {
24542 (char *) "self",(char *) "year", NULL
24543 };
24544
24545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24547 if (!SWIG_IsOK(res1)) {
24548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24549 }
24550 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24551 ecode2 = SWIG_AsVal_int(obj1, &val2);
24552 if (!SWIG_IsOK(ecode2)) {
24553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24554 }
24555 arg2 = static_cast< int >(val2);
24556 {
24557 PyThreadState* __tstate = wxPyBeginAllowThreads();
24558 {
24559 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24560 result = (wxDateTime *) &_result_ref;
24561 }
24562 wxPyEndAllowThreads(__tstate);
24563 if (PyErr_Occurred()) SWIG_fail;
24564 }
24565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24566 return resultobj;
24567 fail:
24568 return NULL;
24569 }
24570
24571
24572 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24573 PyObject *resultobj = 0;
24574 wxDateTime *arg1 = (wxDateTime *) 0 ;
24575 wxDateTime::Month arg2 ;
24576 wxDateTime *result = 0 ;
24577 void *argp1 = 0 ;
24578 int res1 = 0 ;
24579 int val2 ;
24580 int ecode2 = 0 ;
24581 PyObject * obj0 = 0 ;
24582 PyObject * obj1 = 0 ;
24583 char * kwnames[] = {
24584 (char *) "self",(char *) "month", NULL
24585 };
24586
24587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24589 if (!SWIG_IsOK(res1)) {
24590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24591 }
24592 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24593 ecode2 = SWIG_AsVal_int(obj1, &val2);
24594 if (!SWIG_IsOK(ecode2)) {
24595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24596 }
24597 arg2 = static_cast< wxDateTime::Month >(val2);
24598 {
24599 PyThreadState* __tstate = wxPyBeginAllowThreads();
24600 {
24601 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24602 result = (wxDateTime *) &_result_ref;
24603 }
24604 wxPyEndAllowThreads(__tstate);
24605 if (PyErr_Occurred()) SWIG_fail;
24606 }
24607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24608 return resultobj;
24609 fail:
24610 return NULL;
24611 }
24612
24613
24614 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24615 PyObject *resultobj = 0;
24616 wxDateTime *arg1 = (wxDateTime *) 0 ;
24617 int arg2 ;
24618 wxDateTime *result = 0 ;
24619 void *argp1 = 0 ;
24620 int res1 = 0 ;
24621 int val2 ;
24622 int ecode2 = 0 ;
24623 PyObject * obj0 = 0 ;
24624 PyObject * obj1 = 0 ;
24625 char * kwnames[] = {
24626 (char *) "self",(char *) "day", NULL
24627 };
24628
24629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24631 if (!SWIG_IsOK(res1)) {
24632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24633 }
24634 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24635 ecode2 = SWIG_AsVal_int(obj1, &val2);
24636 if (!SWIG_IsOK(ecode2)) {
24637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24638 }
24639 arg2 = static_cast< int >(val2);
24640 {
24641 PyThreadState* __tstate = wxPyBeginAllowThreads();
24642 {
24643 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24644 result = (wxDateTime *) &_result_ref;
24645 }
24646 wxPyEndAllowThreads(__tstate);
24647 if (PyErr_Occurred()) SWIG_fail;
24648 }
24649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24650 return resultobj;
24651 fail:
24652 return NULL;
24653 }
24654
24655
24656 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24657 PyObject *resultobj = 0;
24658 wxDateTime *arg1 = (wxDateTime *) 0 ;
24659 int arg2 ;
24660 wxDateTime *result = 0 ;
24661 void *argp1 = 0 ;
24662 int res1 = 0 ;
24663 int val2 ;
24664 int ecode2 = 0 ;
24665 PyObject * obj0 = 0 ;
24666 PyObject * obj1 = 0 ;
24667 char * kwnames[] = {
24668 (char *) "self",(char *) "hour", NULL
24669 };
24670
24671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24673 if (!SWIG_IsOK(res1)) {
24674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24675 }
24676 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24677 ecode2 = SWIG_AsVal_int(obj1, &val2);
24678 if (!SWIG_IsOK(ecode2)) {
24679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24680 }
24681 arg2 = static_cast< int >(val2);
24682 {
24683 PyThreadState* __tstate = wxPyBeginAllowThreads();
24684 {
24685 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24686 result = (wxDateTime *) &_result_ref;
24687 }
24688 wxPyEndAllowThreads(__tstate);
24689 if (PyErr_Occurred()) SWIG_fail;
24690 }
24691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24692 return resultobj;
24693 fail:
24694 return NULL;
24695 }
24696
24697
24698 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24699 PyObject *resultobj = 0;
24700 wxDateTime *arg1 = (wxDateTime *) 0 ;
24701 int arg2 ;
24702 wxDateTime *result = 0 ;
24703 void *argp1 = 0 ;
24704 int res1 = 0 ;
24705 int val2 ;
24706 int ecode2 = 0 ;
24707 PyObject * obj0 = 0 ;
24708 PyObject * obj1 = 0 ;
24709 char * kwnames[] = {
24710 (char *) "self",(char *) "minute", NULL
24711 };
24712
24713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24715 if (!SWIG_IsOK(res1)) {
24716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24717 }
24718 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24719 ecode2 = SWIG_AsVal_int(obj1, &val2);
24720 if (!SWIG_IsOK(ecode2)) {
24721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24722 }
24723 arg2 = static_cast< int >(val2);
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 {
24727 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24728 result = (wxDateTime *) &_result_ref;
24729 }
24730 wxPyEndAllowThreads(__tstate);
24731 if (PyErr_Occurred()) SWIG_fail;
24732 }
24733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24734 return resultobj;
24735 fail:
24736 return NULL;
24737 }
24738
24739
24740 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24741 PyObject *resultobj = 0;
24742 wxDateTime *arg1 = (wxDateTime *) 0 ;
24743 int arg2 ;
24744 wxDateTime *result = 0 ;
24745 void *argp1 = 0 ;
24746 int res1 = 0 ;
24747 int val2 ;
24748 int ecode2 = 0 ;
24749 PyObject * obj0 = 0 ;
24750 PyObject * obj1 = 0 ;
24751 char * kwnames[] = {
24752 (char *) "self",(char *) "second", NULL
24753 };
24754
24755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24757 if (!SWIG_IsOK(res1)) {
24758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24759 }
24760 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24761 ecode2 = SWIG_AsVal_int(obj1, &val2);
24762 if (!SWIG_IsOK(ecode2)) {
24763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24764 }
24765 arg2 = static_cast< int >(val2);
24766 {
24767 PyThreadState* __tstate = wxPyBeginAllowThreads();
24768 {
24769 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
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_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24783 PyObject *resultobj = 0;
24784 wxDateTime *arg1 = (wxDateTime *) 0 ;
24785 int arg2 ;
24786 wxDateTime *result = 0 ;
24787 void *argp1 = 0 ;
24788 int res1 = 0 ;
24789 int val2 ;
24790 int ecode2 = 0 ;
24791 PyObject * obj0 = 0 ;
24792 PyObject * obj1 = 0 ;
24793 char * kwnames[] = {
24794 (char *) "self",(char *) "millisecond", NULL
24795 };
24796
24797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24799 if (!SWIG_IsOK(res1)) {
24800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24801 }
24802 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24803 ecode2 = SWIG_AsVal_int(obj1, &val2);
24804 if (!SWIG_IsOK(ecode2)) {
24805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24806 }
24807 arg2 = static_cast< int >(val2);
24808 {
24809 PyThreadState* __tstate = wxPyBeginAllowThreads();
24810 {
24811 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24812 result = (wxDateTime *) &_result_ref;
24813 }
24814 wxPyEndAllowThreads(__tstate);
24815 if (PyErr_Occurred()) SWIG_fail;
24816 }
24817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24818 return resultobj;
24819 fail:
24820 return NULL;
24821 }
24822
24823
24824 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24825 PyObject *resultobj = 0;
24826 wxDateTime *arg1 = (wxDateTime *) 0 ;
24827 wxDateTime::WeekDay arg2 ;
24828 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24829 wxDateTime *result = 0 ;
24830 void *argp1 = 0 ;
24831 int res1 = 0 ;
24832 int val2 ;
24833 int ecode2 = 0 ;
24834 int val3 ;
24835 int ecode3 = 0 ;
24836 PyObject * obj0 = 0 ;
24837 PyObject * obj1 = 0 ;
24838 PyObject * obj2 = 0 ;
24839 char * kwnames[] = {
24840 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24841 };
24842
24843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24845 if (!SWIG_IsOK(res1)) {
24846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24847 }
24848 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24849 ecode2 = SWIG_AsVal_int(obj1, &val2);
24850 if (!SWIG_IsOK(ecode2)) {
24851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24852 }
24853 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24854 if (obj2) {
24855 ecode3 = SWIG_AsVal_int(obj2, &val3);
24856 if (!SWIG_IsOK(ecode3)) {
24857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24858 }
24859 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24860 }
24861 {
24862 PyThreadState* __tstate = wxPyBeginAllowThreads();
24863 {
24864 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24865 result = (wxDateTime *) &_result_ref;
24866 }
24867 wxPyEndAllowThreads(__tstate);
24868 if (PyErr_Occurred()) SWIG_fail;
24869 }
24870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24871 return resultobj;
24872 fail:
24873 return NULL;
24874 }
24875
24876
24877 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24878 PyObject *resultobj = 0;
24879 wxDateTime *arg1 = (wxDateTime *) 0 ;
24880 wxDateTime::WeekDay arg2 ;
24881 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24882 wxDateTime result;
24883 void *argp1 = 0 ;
24884 int res1 = 0 ;
24885 int val2 ;
24886 int ecode2 = 0 ;
24887 int val3 ;
24888 int ecode3 = 0 ;
24889 PyObject * obj0 = 0 ;
24890 PyObject * obj1 = 0 ;
24891 PyObject * obj2 = 0 ;
24892 char * kwnames[] = {
24893 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24894 };
24895
24896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24898 if (!SWIG_IsOK(res1)) {
24899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24900 }
24901 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24902 ecode2 = SWIG_AsVal_int(obj1, &val2);
24903 if (!SWIG_IsOK(ecode2)) {
24904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24905 }
24906 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24907 if (obj2) {
24908 ecode3 = SWIG_AsVal_int(obj2, &val3);
24909 if (!SWIG_IsOK(ecode3)) {
24910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24911 }
24912 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24913 }
24914 {
24915 PyThreadState* __tstate = wxPyBeginAllowThreads();
24916 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24917 wxPyEndAllowThreads(__tstate);
24918 if (PyErr_Occurred()) SWIG_fail;
24919 }
24920 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24921 return resultobj;
24922 fail:
24923 return NULL;
24924 }
24925
24926
24927 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24928 PyObject *resultobj = 0;
24929 wxDateTime *arg1 = (wxDateTime *) 0 ;
24930 wxDateTime::WeekDay arg2 ;
24931 wxDateTime *result = 0 ;
24932 void *argp1 = 0 ;
24933 int res1 = 0 ;
24934 int val2 ;
24935 int ecode2 = 0 ;
24936 PyObject * obj0 = 0 ;
24937 PyObject * obj1 = 0 ;
24938 char * kwnames[] = {
24939 (char *) "self",(char *) "weekday", NULL
24940 };
24941
24942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24944 if (!SWIG_IsOK(res1)) {
24945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24946 }
24947 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24948 ecode2 = SWIG_AsVal_int(obj1, &val2);
24949 if (!SWIG_IsOK(ecode2)) {
24950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24951 }
24952 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24953 {
24954 PyThreadState* __tstate = wxPyBeginAllowThreads();
24955 {
24956 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24957 result = (wxDateTime *) &_result_ref;
24958 }
24959 wxPyEndAllowThreads(__tstate);
24960 if (PyErr_Occurred()) SWIG_fail;
24961 }
24962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24970 PyObject *resultobj = 0;
24971 wxDateTime *arg1 = (wxDateTime *) 0 ;
24972 wxDateTime::WeekDay arg2 ;
24973 wxDateTime result;
24974 void *argp1 = 0 ;
24975 int res1 = 0 ;
24976 int val2 ;
24977 int ecode2 = 0 ;
24978 PyObject * obj0 = 0 ;
24979 PyObject * obj1 = 0 ;
24980 char * kwnames[] = {
24981 (char *) "self",(char *) "weekday", NULL
24982 };
24983
24984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24986 if (!SWIG_IsOK(res1)) {
24987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24988 }
24989 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24990 ecode2 = SWIG_AsVal_int(obj1, &val2);
24991 if (!SWIG_IsOK(ecode2)) {
24992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24993 }
24994 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24995 {
24996 PyThreadState* __tstate = wxPyBeginAllowThreads();
24997 result = (arg1)->GetNextWeekDay(arg2);
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25002 return resultobj;
25003 fail:
25004 return NULL;
25005 }
25006
25007
25008 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25009 PyObject *resultobj = 0;
25010 wxDateTime *arg1 = (wxDateTime *) 0 ;
25011 wxDateTime::WeekDay arg2 ;
25012 wxDateTime *result = 0 ;
25013 void *argp1 = 0 ;
25014 int res1 = 0 ;
25015 int val2 ;
25016 int ecode2 = 0 ;
25017 PyObject * obj0 = 0 ;
25018 PyObject * obj1 = 0 ;
25019 char * kwnames[] = {
25020 (char *) "self",(char *) "weekday", NULL
25021 };
25022
25023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25025 if (!SWIG_IsOK(res1)) {
25026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25027 }
25028 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25029 ecode2 = SWIG_AsVal_int(obj1, &val2);
25030 if (!SWIG_IsOK(ecode2)) {
25031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25032 }
25033 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 {
25037 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
25038 result = (wxDateTime *) &_result_ref;
25039 }
25040 wxPyEndAllowThreads(__tstate);
25041 if (PyErr_Occurred()) SWIG_fail;
25042 }
25043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25044 return resultobj;
25045 fail:
25046 return NULL;
25047 }
25048
25049
25050 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25051 PyObject *resultobj = 0;
25052 wxDateTime *arg1 = (wxDateTime *) 0 ;
25053 wxDateTime::WeekDay arg2 ;
25054 wxDateTime result;
25055 void *argp1 = 0 ;
25056 int res1 = 0 ;
25057 int val2 ;
25058 int ecode2 = 0 ;
25059 PyObject * obj0 = 0 ;
25060 PyObject * obj1 = 0 ;
25061 char * kwnames[] = {
25062 (char *) "self",(char *) "weekday", NULL
25063 };
25064
25065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25067 if (!SWIG_IsOK(res1)) {
25068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25069 }
25070 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25071 ecode2 = SWIG_AsVal_int(obj1, &val2);
25072 if (!SWIG_IsOK(ecode2)) {
25073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25074 }
25075 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25076 {
25077 PyThreadState* __tstate = wxPyBeginAllowThreads();
25078 result = (arg1)->GetPrevWeekDay(arg2);
25079 wxPyEndAllowThreads(__tstate);
25080 if (PyErr_Occurred()) SWIG_fail;
25081 }
25082 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25083 return resultobj;
25084 fail:
25085 return NULL;
25086 }
25087
25088
25089 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25090 PyObject *resultobj = 0;
25091 wxDateTime *arg1 = (wxDateTime *) 0 ;
25092 wxDateTime::WeekDay arg2 ;
25093 int arg3 = (int) 1 ;
25094 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25095 int arg5 = (int) wxDateTime::Inv_Year ;
25096 bool result;
25097 void *argp1 = 0 ;
25098 int res1 = 0 ;
25099 int val2 ;
25100 int ecode2 = 0 ;
25101 int val3 ;
25102 int ecode3 = 0 ;
25103 int val4 ;
25104 int ecode4 = 0 ;
25105 int val5 ;
25106 int ecode5 = 0 ;
25107 PyObject * obj0 = 0 ;
25108 PyObject * obj1 = 0 ;
25109 PyObject * obj2 = 0 ;
25110 PyObject * obj3 = 0 ;
25111 PyObject * obj4 = 0 ;
25112 char * kwnames[] = {
25113 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25114 };
25115
25116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25118 if (!SWIG_IsOK(res1)) {
25119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25120 }
25121 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25122 ecode2 = SWIG_AsVal_int(obj1, &val2);
25123 if (!SWIG_IsOK(ecode2)) {
25124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25125 }
25126 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25127 if (obj2) {
25128 ecode3 = SWIG_AsVal_int(obj2, &val3);
25129 if (!SWIG_IsOK(ecode3)) {
25130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25131 }
25132 arg3 = static_cast< int >(val3);
25133 }
25134 if (obj3) {
25135 ecode4 = SWIG_AsVal_int(obj3, &val4);
25136 if (!SWIG_IsOK(ecode4)) {
25137 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25138 }
25139 arg4 = static_cast< wxDateTime::Month >(val4);
25140 }
25141 if (obj4) {
25142 ecode5 = SWIG_AsVal_int(obj4, &val5);
25143 if (!SWIG_IsOK(ecode5)) {
25144 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25145 }
25146 arg5 = static_cast< int >(val5);
25147 }
25148 {
25149 PyThreadState* __tstate = wxPyBeginAllowThreads();
25150 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25151 wxPyEndAllowThreads(__tstate);
25152 if (PyErr_Occurred()) SWIG_fail;
25153 }
25154 {
25155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25156 }
25157 return resultobj;
25158 fail:
25159 return NULL;
25160 }
25161
25162
25163 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25164 PyObject *resultobj = 0;
25165 wxDateTime *arg1 = (wxDateTime *) 0 ;
25166 wxDateTime::WeekDay arg2 ;
25167 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25168 int arg4 = (int) wxDateTime::Inv_Year ;
25169 bool result;
25170 void *argp1 = 0 ;
25171 int res1 = 0 ;
25172 int val2 ;
25173 int ecode2 = 0 ;
25174 int val3 ;
25175 int ecode3 = 0 ;
25176 int val4 ;
25177 int ecode4 = 0 ;
25178 PyObject * obj0 = 0 ;
25179 PyObject * obj1 = 0 ;
25180 PyObject * obj2 = 0 ;
25181 PyObject * obj3 = 0 ;
25182 char * kwnames[] = {
25183 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25184 };
25185
25186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25188 if (!SWIG_IsOK(res1)) {
25189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25190 }
25191 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25192 ecode2 = SWIG_AsVal_int(obj1, &val2);
25193 if (!SWIG_IsOK(ecode2)) {
25194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25195 }
25196 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25197 if (obj2) {
25198 ecode3 = SWIG_AsVal_int(obj2, &val3);
25199 if (!SWIG_IsOK(ecode3)) {
25200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25201 }
25202 arg3 = static_cast< wxDateTime::Month >(val3);
25203 }
25204 if (obj3) {
25205 ecode4 = SWIG_AsVal_int(obj3, &val4);
25206 if (!SWIG_IsOK(ecode4)) {
25207 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25208 }
25209 arg4 = static_cast< int >(val4);
25210 }
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 {
25218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25219 }
25220 return resultobj;
25221 fail:
25222 return NULL;
25223 }
25224
25225
25226 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25227 PyObject *resultobj = 0;
25228 wxDateTime *arg1 = (wxDateTime *) 0 ;
25229 wxDateTime::WeekDay arg2 ;
25230 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25231 int arg4 = (int) wxDateTime::Inv_Year ;
25232 wxDateTime result;
25233 void *argp1 = 0 ;
25234 int res1 = 0 ;
25235 int val2 ;
25236 int ecode2 = 0 ;
25237 int val3 ;
25238 int ecode3 = 0 ;
25239 int val4 ;
25240 int ecode4 = 0 ;
25241 PyObject * obj0 = 0 ;
25242 PyObject * obj1 = 0 ;
25243 PyObject * obj2 = 0 ;
25244 PyObject * obj3 = 0 ;
25245 char * kwnames[] = {
25246 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25247 };
25248
25249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25251 if (!SWIG_IsOK(res1)) {
25252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25253 }
25254 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25255 ecode2 = SWIG_AsVal_int(obj1, &val2);
25256 if (!SWIG_IsOK(ecode2)) {
25257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25258 }
25259 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25260 if (obj2) {
25261 ecode3 = SWIG_AsVal_int(obj2, &val3);
25262 if (!SWIG_IsOK(ecode3)) {
25263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25264 }
25265 arg3 = static_cast< wxDateTime::Month >(val3);
25266 }
25267 if (obj3) {
25268 ecode4 = SWIG_AsVal_int(obj3, &val4);
25269 if (!SWIG_IsOK(ecode4)) {
25270 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25271 }
25272 arg4 = static_cast< int >(val4);
25273 }
25274 {
25275 PyThreadState* __tstate = wxPyBeginAllowThreads();
25276 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25277 wxPyEndAllowThreads(__tstate);
25278 if (PyErr_Occurred()) SWIG_fail;
25279 }
25280 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25281 return resultobj;
25282 fail:
25283 return NULL;
25284 }
25285
25286
25287 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25288 PyObject *resultobj = 0;
25289 int arg1 ;
25290 int arg2 ;
25291 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25292 wxDateTime result;
25293 int val1 ;
25294 int ecode1 = 0 ;
25295 int val2 ;
25296 int ecode2 = 0 ;
25297 int val3 ;
25298 int ecode3 = 0 ;
25299 PyObject * obj0 = 0 ;
25300 PyObject * obj1 = 0 ;
25301 PyObject * obj2 = 0 ;
25302 char * kwnames[] = {
25303 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25304 };
25305
25306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25307 ecode1 = SWIG_AsVal_int(obj0, &val1);
25308 if (!SWIG_IsOK(ecode1)) {
25309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25310 }
25311 arg1 = static_cast< int >(val1);
25312 ecode2 = SWIG_AsVal_int(obj1, &val2);
25313 if (!SWIG_IsOK(ecode2)) {
25314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25315 }
25316 arg2 = static_cast< int >(val2);
25317 if (obj2) {
25318 ecode3 = SWIG_AsVal_int(obj2, &val3);
25319 if (!SWIG_IsOK(ecode3)) {
25320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25321 }
25322 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25323 }
25324 {
25325 PyThreadState* __tstate = wxPyBeginAllowThreads();
25326 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25327 wxPyEndAllowThreads(__tstate);
25328 if (PyErr_Occurred()) SWIG_fail;
25329 }
25330 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25331 return resultobj;
25332 fail:
25333 return NULL;
25334 }
25335
25336
25337 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25338 PyObject *resultobj = 0;
25339 wxDateTime *arg1 = (wxDateTime *) 0 ;
25340 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25341 int arg3 = (int) wxDateTime::Inv_Year ;
25342 wxDateTime *result = 0 ;
25343 void *argp1 = 0 ;
25344 int res1 = 0 ;
25345 int val2 ;
25346 int ecode2 = 0 ;
25347 int val3 ;
25348 int ecode3 = 0 ;
25349 PyObject * obj0 = 0 ;
25350 PyObject * obj1 = 0 ;
25351 PyObject * obj2 = 0 ;
25352 char * kwnames[] = {
25353 (char *) "self",(char *) "month",(char *) "year", NULL
25354 };
25355
25356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25358 if (!SWIG_IsOK(res1)) {
25359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25360 }
25361 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25362 if (obj1) {
25363 ecode2 = SWIG_AsVal_int(obj1, &val2);
25364 if (!SWIG_IsOK(ecode2)) {
25365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25366 }
25367 arg2 = static_cast< wxDateTime::Month >(val2);
25368 }
25369 if (obj2) {
25370 ecode3 = SWIG_AsVal_int(obj2, &val3);
25371 if (!SWIG_IsOK(ecode3)) {
25372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25373 }
25374 arg3 = static_cast< int >(val3);
25375 }
25376 {
25377 PyThreadState* __tstate = wxPyBeginAllowThreads();
25378 {
25379 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25380 result = (wxDateTime *) &_result_ref;
25381 }
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25386 return resultobj;
25387 fail:
25388 return NULL;
25389 }
25390
25391
25392 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25393 PyObject *resultobj = 0;
25394 wxDateTime *arg1 = (wxDateTime *) 0 ;
25395 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25396 int arg3 = (int) wxDateTime::Inv_Year ;
25397 wxDateTime result;
25398 void *argp1 = 0 ;
25399 int res1 = 0 ;
25400 int val2 ;
25401 int ecode2 = 0 ;
25402 int val3 ;
25403 int ecode3 = 0 ;
25404 PyObject * obj0 = 0 ;
25405 PyObject * obj1 = 0 ;
25406 PyObject * obj2 = 0 ;
25407 char * kwnames[] = {
25408 (char *) "self",(char *) "month",(char *) "year", NULL
25409 };
25410
25411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25413 if (!SWIG_IsOK(res1)) {
25414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25415 }
25416 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25417 if (obj1) {
25418 ecode2 = SWIG_AsVal_int(obj1, &val2);
25419 if (!SWIG_IsOK(ecode2)) {
25420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25421 }
25422 arg2 = static_cast< wxDateTime::Month >(val2);
25423 }
25424 if (obj2) {
25425 ecode3 = SWIG_AsVal_int(obj2, &val3);
25426 if (!SWIG_IsOK(ecode3)) {
25427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25428 }
25429 arg3 = static_cast< int >(val3);
25430 }
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 result = (arg1)->GetLastMonthDay(arg2,arg3);
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25445 PyObject *resultobj = 0;
25446 wxDateTime *arg1 = (wxDateTime *) 0 ;
25447 int arg2 ;
25448 wxDateTime *result = 0 ;
25449 void *argp1 = 0 ;
25450 int res1 = 0 ;
25451 int val2 ;
25452 int ecode2 = 0 ;
25453 PyObject * obj0 = 0 ;
25454 PyObject * obj1 = 0 ;
25455 char * kwnames[] = {
25456 (char *) "self",(char *) "yday", NULL
25457 };
25458
25459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25461 if (!SWIG_IsOK(res1)) {
25462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25463 }
25464 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25465 ecode2 = SWIG_AsVal_int(obj1, &val2);
25466 if (!SWIG_IsOK(ecode2)) {
25467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25468 }
25469 arg2 = static_cast< int >(val2);
25470 {
25471 PyThreadState* __tstate = wxPyBeginAllowThreads();
25472 {
25473 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25474 result = (wxDateTime *) &_result_ref;
25475 }
25476 wxPyEndAllowThreads(__tstate);
25477 if (PyErr_Occurred()) SWIG_fail;
25478 }
25479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25480 return resultobj;
25481 fail:
25482 return NULL;
25483 }
25484
25485
25486 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25487 PyObject *resultobj = 0;
25488 wxDateTime *arg1 = (wxDateTime *) 0 ;
25489 int arg2 ;
25490 wxDateTime result;
25491 void *argp1 = 0 ;
25492 int res1 = 0 ;
25493 int val2 ;
25494 int ecode2 = 0 ;
25495 PyObject * obj0 = 0 ;
25496 PyObject * obj1 = 0 ;
25497 char * kwnames[] = {
25498 (char *) "self",(char *) "yday", NULL
25499 };
25500
25501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25503 if (!SWIG_IsOK(res1)) {
25504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25505 }
25506 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25507 ecode2 = SWIG_AsVal_int(obj1, &val2);
25508 if (!SWIG_IsOK(ecode2)) {
25509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25510 }
25511 arg2 = static_cast< int >(val2);
25512 {
25513 PyThreadState* __tstate = wxPyBeginAllowThreads();
25514 result = (arg1)->GetYearDay(arg2);
25515 wxPyEndAllowThreads(__tstate);
25516 if (PyErr_Occurred()) SWIG_fail;
25517 }
25518 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25519 return resultobj;
25520 fail:
25521 return NULL;
25522 }
25523
25524
25525 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25526 PyObject *resultobj = 0;
25527 wxDateTime *arg1 = (wxDateTime *) 0 ;
25528 double result;
25529 void *argp1 = 0 ;
25530 int res1 = 0 ;
25531 PyObject *swig_obj[1] ;
25532
25533 if (!args) SWIG_fail;
25534 swig_obj[0] = args;
25535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25536 if (!SWIG_IsOK(res1)) {
25537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25538 }
25539 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25540 {
25541 PyThreadState* __tstate = wxPyBeginAllowThreads();
25542 result = (double)(arg1)->GetJulianDayNumber();
25543 wxPyEndAllowThreads(__tstate);
25544 if (PyErr_Occurred()) SWIG_fail;
25545 }
25546 resultobj = SWIG_From_double(static_cast< double >(result));
25547 return resultobj;
25548 fail:
25549 return NULL;
25550 }
25551
25552
25553 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25554 PyObject *resultobj = 0;
25555 wxDateTime *arg1 = (wxDateTime *) 0 ;
25556 double result;
25557 void *argp1 = 0 ;
25558 int res1 = 0 ;
25559 PyObject *swig_obj[1] ;
25560
25561 if (!args) SWIG_fail;
25562 swig_obj[0] = args;
25563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25564 if (!SWIG_IsOK(res1)) {
25565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25566 }
25567 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25568 {
25569 PyThreadState* __tstate = wxPyBeginAllowThreads();
25570 result = (double)(arg1)->GetJDN();
25571 wxPyEndAllowThreads(__tstate);
25572 if (PyErr_Occurred()) SWIG_fail;
25573 }
25574 resultobj = SWIG_From_double(static_cast< double >(result));
25575 return resultobj;
25576 fail:
25577 return NULL;
25578 }
25579
25580
25581 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25582 PyObject *resultobj = 0;
25583 wxDateTime *arg1 = (wxDateTime *) 0 ;
25584 double result;
25585 void *argp1 = 0 ;
25586 int res1 = 0 ;
25587 PyObject *swig_obj[1] ;
25588
25589 if (!args) SWIG_fail;
25590 swig_obj[0] = args;
25591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25592 if (!SWIG_IsOK(res1)) {
25593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25594 }
25595 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25599 wxPyEndAllowThreads(__tstate);
25600 if (PyErr_Occurred()) SWIG_fail;
25601 }
25602 resultobj = SWIG_From_double(static_cast< double >(result));
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25610 PyObject *resultobj = 0;
25611 wxDateTime *arg1 = (wxDateTime *) 0 ;
25612 double result;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 PyObject *swig_obj[1] ;
25616
25617 if (!args) SWIG_fail;
25618 swig_obj[0] = args;
25619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25620 if (!SWIG_IsOK(res1)) {
25621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25622 }
25623 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = (double)(arg1)->GetMJD();
25627 wxPyEndAllowThreads(__tstate);
25628 if (PyErr_Occurred()) SWIG_fail;
25629 }
25630 resultobj = SWIG_From_double(static_cast< double >(result));
25631 return resultobj;
25632 fail:
25633 return NULL;
25634 }
25635
25636
25637 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25638 PyObject *resultobj = 0;
25639 wxDateTime *arg1 = (wxDateTime *) 0 ;
25640 double result;
25641 void *argp1 = 0 ;
25642 int res1 = 0 ;
25643 PyObject *swig_obj[1] ;
25644
25645 if (!args) SWIG_fail;
25646 swig_obj[0] = args;
25647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25648 if (!SWIG_IsOK(res1)) {
25649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25650 }
25651 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 result = (double)(arg1)->GetRataDie();
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 resultobj = SWIG_From_double(static_cast< double >(result));
25659 return resultobj;
25660 fail:
25661 return NULL;
25662 }
25663
25664
25665 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25666 PyObject *resultobj = 0;
25667 wxDateTime *arg1 = (wxDateTime *) 0 ;
25668 wxDateTime::TimeZone *arg2 = 0 ;
25669 bool arg3 = (bool) false ;
25670 wxDateTime result;
25671 void *argp1 = 0 ;
25672 int res1 = 0 ;
25673 bool temp2 = false ;
25674 bool val3 ;
25675 int ecode3 = 0 ;
25676 PyObject * obj0 = 0 ;
25677 PyObject * obj1 = 0 ;
25678 PyObject * obj2 = 0 ;
25679 char * kwnames[] = {
25680 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25681 };
25682
25683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25685 if (!SWIG_IsOK(res1)) {
25686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25687 }
25688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25689 {
25690 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25691 temp2 = true;
25692 }
25693 if (obj2) {
25694 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25695 if (!SWIG_IsOK(ecode3)) {
25696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25697 }
25698 arg3 = static_cast< bool >(val3);
25699 }
25700 {
25701 PyThreadState* __tstate = wxPyBeginAllowThreads();
25702 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25707 {
25708 if (temp2) delete arg2;
25709 }
25710 return resultobj;
25711 fail:
25712 {
25713 if (temp2) delete arg2;
25714 }
25715 return NULL;
25716 }
25717
25718
25719 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25720 PyObject *resultobj = 0;
25721 wxDateTime *arg1 = (wxDateTime *) 0 ;
25722 wxDateTime::TimeZone *arg2 = 0 ;
25723 bool arg3 = (bool) false ;
25724 wxDateTime *result = 0 ;
25725 void *argp1 = 0 ;
25726 int res1 = 0 ;
25727 bool temp2 = false ;
25728 bool val3 ;
25729 int ecode3 = 0 ;
25730 PyObject * obj0 = 0 ;
25731 PyObject * obj1 = 0 ;
25732 PyObject * obj2 = 0 ;
25733 char * kwnames[] = {
25734 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25735 };
25736
25737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25739 if (!SWIG_IsOK(res1)) {
25740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25741 }
25742 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25743 {
25744 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25745 temp2 = true;
25746 }
25747 if (obj2) {
25748 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25749 if (!SWIG_IsOK(ecode3)) {
25750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25751 }
25752 arg3 = static_cast< bool >(val3);
25753 }
25754 {
25755 PyThreadState* __tstate = wxPyBeginAllowThreads();
25756 {
25757 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25758 result = (wxDateTime *) &_result_ref;
25759 }
25760 wxPyEndAllowThreads(__tstate);
25761 if (PyErr_Occurred()) SWIG_fail;
25762 }
25763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25764 {
25765 if (temp2) delete arg2;
25766 }
25767 return resultobj;
25768 fail:
25769 {
25770 if (temp2) delete arg2;
25771 }
25772 return NULL;
25773 }
25774
25775
25776 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25777 PyObject *resultobj = 0;
25778 wxDateTime *arg1 = (wxDateTime *) 0 ;
25779 wxDateTime::TimeZone *arg2 = 0 ;
25780 bool arg3 = (bool) false ;
25781 wxDateTime result;
25782 void *argp1 = 0 ;
25783 int res1 = 0 ;
25784 bool temp2 = false ;
25785 bool val3 ;
25786 int ecode3 = 0 ;
25787 PyObject * obj0 = 0 ;
25788 PyObject * obj1 = 0 ;
25789 PyObject * obj2 = 0 ;
25790 char * kwnames[] = {
25791 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25792 };
25793
25794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25796 if (!SWIG_IsOK(res1)) {
25797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25798 }
25799 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25800 {
25801 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25802 temp2 = true;
25803 }
25804 if (obj2) {
25805 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25806 if (!SWIG_IsOK(ecode3)) {
25807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25808 }
25809 arg3 = static_cast< bool >(val3);
25810 }
25811 {
25812 PyThreadState* __tstate = wxPyBeginAllowThreads();
25813 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25814 wxPyEndAllowThreads(__tstate);
25815 if (PyErr_Occurred()) SWIG_fail;
25816 }
25817 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25818 {
25819 if (temp2) delete arg2;
25820 }
25821 return resultobj;
25822 fail:
25823 {
25824 if (temp2) delete arg2;
25825 }
25826 return NULL;
25827 }
25828
25829
25830 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25831 PyObject *resultobj = 0;
25832 wxDateTime *arg1 = (wxDateTime *) 0 ;
25833 wxDateTime::TimeZone *arg2 = 0 ;
25834 bool arg3 = (bool) false ;
25835 wxDateTime *result = 0 ;
25836 void *argp1 = 0 ;
25837 int res1 = 0 ;
25838 bool temp2 = false ;
25839 bool val3 ;
25840 int ecode3 = 0 ;
25841 PyObject * obj0 = 0 ;
25842 PyObject * obj1 = 0 ;
25843 PyObject * obj2 = 0 ;
25844 char * kwnames[] = {
25845 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25846 };
25847
25848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25850 if (!SWIG_IsOK(res1)) {
25851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25852 }
25853 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25854 {
25855 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25856 temp2 = true;
25857 }
25858 if (obj2) {
25859 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25860 if (!SWIG_IsOK(ecode3)) {
25861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25862 }
25863 arg3 = static_cast< bool >(val3);
25864 }
25865 {
25866 PyThreadState* __tstate = wxPyBeginAllowThreads();
25867 {
25868 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25869 result = (wxDateTime *) &_result_ref;
25870 }
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25875 {
25876 if (temp2) delete arg2;
25877 }
25878 return resultobj;
25879 fail:
25880 {
25881 if (temp2) delete arg2;
25882 }
25883 return NULL;
25884 }
25885
25886
25887 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25888 PyObject *resultobj = 0;
25889 wxDateTime *arg1 = (wxDateTime *) 0 ;
25890 bool arg2 = (bool) false ;
25891 wxDateTime result;
25892 void *argp1 = 0 ;
25893 int res1 = 0 ;
25894 bool val2 ;
25895 int ecode2 = 0 ;
25896 PyObject * obj0 = 0 ;
25897 PyObject * obj1 = 0 ;
25898 char * kwnames[] = {
25899 (char *) "self",(char *) "noDST", NULL
25900 };
25901
25902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25904 if (!SWIG_IsOK(res1)) {
25905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25906 }
25907 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25908 if (obj1) {
25909 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25910 if (!SWIG_IsOK(ecode2)) {
25911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25912 }
25913 arg2 = static_cast< bool >(val2);
25914 }
25915 {
25916 PyThreadState* __tstate = wxPyBeginAllowThreads();
25917 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25918 wxPyEndAllowThreads(__tstate);
25919 if (PyErr_Occurred()) SWIG_fail;
25920 }
25921 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25922 return resultobj;
25923 fail:
25924 return NULL;
25925 }
25926
25927
25928 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25929 PyObject *resultobj = 0;
25930 wxDateTime *arg1 = (wxDateTime *) 0 ;
25931 bool arg2 = (bool) false ;
25932 wxDateTime *result = 0 ;
25933 void *argp1 = 0 ;
25934 int res1 = 0 ;
25935 bool val2 ;
25936 int ecode2 = 0 ;
25937 PyObject * obj0 = 0 ;
25938 PyObject * obj1 = 0 ;
25939 char * kwnames[] = {
25940 (char *) "self",(char *) "noDST", NULL
25941 };
25942
25943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25945 if (!SWIG_IsOK(res1)) {
25946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25947 }
25948 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25949 if (obj1) {
25950 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25951 if (!SWIG_IsOK(ecode2)) {
25952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25953 }
25954 arg2 = static_cast< bool >(val2);
25955 }
25956 {
25957 PyThreadState* __tstate = wxPyBeginAllowThreads();
25958 {
25959 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25960 result = (wxDateTime *) &_result_ref;
25961 }
25962 wxPyEndAllowThreads(__tstate);
25963 if (PyErr_Occurred()) SWIG_fail;
25964 }
25965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25966 return resultobj;
25967 fail:
25968 return NULL;
25969 }
25970
25971
25972 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25973 PyObject *resultobj = 0;
25974 wxDateTime *arg1 = (wxDateTime *) 0 ;
25975 bool arg2 = (bool) false ;
25976 wxDateTime result;
25977 void *argp1 = 0 ;
25978 int res1 = 0 ;
25979 bool val2 ;
25980 int ecode2 = 0 ;
25981 PyObject * obj0 = 0 ;
25982 PyObject * obj1 = 0 ;
25983 char * kwnames[] = {
25984 (char *) "self",(char *) "noDST", NULL
25985 };
25986
25987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25989 if (!SWIG_IsOK(res1)) {
25990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25991 }
25992 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25993 if (obj1) {
25994 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25995 if (!SWIG_IsOK(ecode2)) {
25996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25997 }
25998 arg2 = static_cast< bool >(val2);
25999 }
26000 {
26001 PyThreadState* __tstate = wxPyBeginAllowThreads();
26002 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26003 wxPyEndAllowThreads(__tstate);
26004 if (PyErr_Occurred()) SWIG_fail;
26005 }
26006 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26007 return resultobj;
26008 fail:
26009 return NULL;
26010 }
26011
26012
26013 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26014 PyObject *resultobj = 0;
26015 wxDateTime *arg1 = (wxDateTime *) 0 ;
26016 bool arg2 = (bool) false ;
26017 wxDateTime *result = 0 ;
26018 void *argp1 = 0 ;
26019 int res1 = 0 ;
26020 bool val2 ;
26021 int ecode2 = 0 ;
26022 PyObject * obj0 = 0 ;
26023 PyObject * obj1 = 0 ;
26024 char * kwnames[] = {
26025 (char *) "self",(char *) "noDST", NULL
26026 };
26027
26028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26030 if (!SWIG_IsOK(res1)) {
26031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26032 }
26033 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26034 if (obj1) {
26035 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26036 if (!SWIG_IsOK(ecode2)) {
26037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26038 }
26039 arg2 = static_cast< bool >(val2);
26040 }
26041 {
26042 PyThreadState* __tstate = wxPyBeginAllowThreads();
26043 {
26044 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26045 result = (wxDateTime *) &_result_ref;
26046 }
26047 wxPyEndAllowThreads(__tstate);
26048 if (PyErr_Occurred()) SWIG_fail;
26049 }
26050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26058 PyObject *resultobj = 0;
26059 wxDateTime *arg1 = (wxDateTime *) 0 ;
26060 bool arg2 = (bool) false ;
26061 wxDateTime result;
26062 void *argp1 = 0 ;
26063 int res1 = 0 ;
26064 bool val2 ;
26065 int ecode2 = 0 ;
26066 PyObject * obj0 = 0 ;
26067 PyObject * obj1 = 0 ;
26068 char * kwnames[] = {
26069 (char *) "self",(char *) "noDST", NULL
26070 };
26071
26072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26074 if (!SWIG_IsOK(res1)) {
26075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26076 }
26077 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26078 if (obj1) {
26079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26080 if (!SWIG_IsOK(ecode2)) {
26081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26082 }
26083 arg2 = static_cast< bool >(val2);
26084 }
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26092 return resultobj;
26093 fail:
26094 return NULL;
26095 }
26096
26097
26098 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26099 PyObject *resultobj = 0;
26100 wxDateTime *arg1 = (wxDateTime *) 0 ;
26101 bool arg2 = (bool) false ;
26102 wxDateTime *result = 0 ;
26103 void *argp1 = 0 ;
26104 int res1 = 0 ;
26105 bool val2 ;
26106 int ecode2 = 0 ;
26107 PyObject * obj0 = 0 ;
26108 PyObject * obj1 = 0 ;
26109 char * kwnames[] = {
26110 (char *) "self",(char *) "noDST", NULL
26111 };
26112
26113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26115 if (!SWIG_IsOK(res1)) {
26116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26117 }
26118 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26119 if (obj1) {
26120 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26121 if (!SWIG_IsOK(ecode2)) {
26122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26123 }
26124 arg2 = static_cast< bool >(val2);
26125 }
26126 {
26127 PyThreadState* __tstate = wxPyBeginAllowThreads();
26128 {
26129 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26130 result = (wxDateTime *) &_result_ref;
26131 }
26132 wxPyEndAllowThreads(__tstate);
26133 if (PyErr_Occurred()) SWIG_fail;
26134 }
26135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26136 return resultobj;
26137 fail:
26138 return NULL;
26139 }
26140
26141
26142 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26143 PyObject *resultobj = 0;
26144 wxDateTime *arg1 = (wxDateTime *) 0 ;
26145 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26146 int result;
26147 void *argp1 = 0 ;
26148 int res1 = 0 ;
26149 int val2 ;
26150 int ecode2 = 0 ;
26151 PyObject * obj0 = 0 ;
26152 PyObject * obj1 = 0 ;
26153 char * kwnames[] = {
26154 (char *) "self",(char *) "country", NULL
26155 };
26156
26157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26159 if (!SWIG_IsOK(res1)) {
26160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26161 }
26162 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26163 if (obj1) {
26164 ecode2 = SWIG_AsVal_int(obj1, &val2);
26165 if (!SWIG_IsOK(ecode2)) {
26166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26167 }
26168 arg2 = static_cast< wxDateTime::Country >(val2);
26169 }
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 result = (int)(arg1)->IsDST(arg2);
26173 wxPyEndAllowThreads(__tstate);
26174 if (PyErr_Occurred()) SWIG_fail;
26175 }
26176 resultobj = SWIG_From_int(static_cast< int >(result));
26177 return resultobj;
26178 fail:
26179 return NULL;
26180 }
26181
26182
26183 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26184 PyObject *resultobj = 0;
26185 wxDateTime *arg1 = (wxDateTime *) 0 ;
26186 bool result;
26187 void *argp1 = 0 ;
26188 int res1 = 0 ;
26189 PyObject *swig_obj[1] ;
26190
26191 if (!args) SWIG_fail;
26192 swig_obj[0] = args;
26193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26194 if (!SWIG_IsOK(res1)) {
26195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26196 }
26197 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26198 {
26199 PyThreadState* __tstate = wxPyBeginAllowThreads();
26200 result = (bool)((wxDateTime const *)arg1)->IsValid();
26201 wxPyEndAllowThreads(__tstate);
26202 if (PyErr_Occurred()) SWIG_fail;
26203 }
26204 {
26205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26206 }
26207 return resultobj;
26208 fail:
26209 return NULL;
26210 }
26211
26212
26213 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26214 PyObject *resultobj = 0;
26215 wxDateTime *arg1 = (wxDateTime *) 0 ;
26216 time_t result;
26217 void *argp1 = 0 ;
26218 int res1 = 0 ;
26219 PyObject *swig_obj[1] ;
26220
26221 if (!args) SWIG_fail;
26222 swig_obj[0] = args;
26223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26224 if (!SWIG_IsOK(res1)) {
26225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26226 }
26227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26228 {
26229 PyThreadState* __tstate = wxPyBeginAllowThreads();
26230 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26231 wxPyEndAllowThreads(__tstate);
26232 if (PyErr_Occurred()) SWIG_fail;
26233 }
26234 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26235 return resultobj;
26236 fail:
26237 return NULL;
26238 }
26239
26240
26241 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26242 PyObject *resultobj = 0;
26243 wxDateTime *arg1 = (wxDateTime *) 0 ;
26244 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26245 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26246 int result;
26247 void *argp1 = 0 ;
26248 int res1 = 0 ;
26249 bool temp2 = false ;
26250 PyObject * obj0 = 0 ;
26251 PyObject * obj1 = 0 ;
26252 char * kwnames[] = {
26253 (char *) "self",(char *) "tz", NULL
26254 };
26255
26256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26258 if (!SWIG_IsOK(res1)) {
26259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26260 }
26261 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26262 if (obj1) {
26263 {
26264 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26265 temp2 = true;
26266 }
26267 }
26268 {
26269 PyThreadState* __tstate = wxPyBeginAllowThreads();
26270 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 resultobj = SWIG_From_int(static_cast< int >(result));
26275 {
26276 if (temp2) delete arg2;
26277 }
26278 return resultobj;
26279 fail:
26280 {
26281 if (temp2) delete arg2;
26282 }
26283 return NULL;
26284 }
26285
26286
26287 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26288 PyObject *resultobj = 0;
26289 wxDateTime *arg1 = (wxDateTime *) 0 ;
26290 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26291 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26292 wxDateTime::Month result;
26293 void *argp1 = 0 ;
26294 int res1 = 0 ;
26295 bool temp2 = false ;
26296 PyObject * obj0 = 0 ;
26297 PyObject * obj1 = 0 ;
26298 char * kwnames[] = {
26299 (char *) "self",(char *) "tz", NULL
26300 };
26301
26302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26304 if (!SWIG_IsOK(res1)) {
26305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26306 }
26307 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26308 if (obj1) {
26309 {
26310 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26311 temp2 = true;
26312 }
26313 }
26314 {
26315 PyThreadState* __tstate = wxPyBeginAllowThreads();
26316 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26317 wxPyEndAllowThreads(__tstate);
26318 if (PyErr_Occurred()) SWIG_fail;
26319 }
26320 resultobj = SWIG_From_int(static_cast< int >(result));
26321 {
26322 if (temp2) delete arg2;
26323 }
26324 return resultobj;
26325 fail:
26326 {
26327 if (temp2) delete arg2;
26328 }
26329 return NULL;
26330 }
26331
26332
26333 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26334 PyObject *resultobj = 0;
26335 wxDateTime *arg1 = (wxDateTime *) 0 ;
26336 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26337 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26338 int result;
26339 void *argp1 = 0 ;
26340 int res1 = 0 ;
26341 bool temp2 = false ;
26342 PyObject * obj0 = 0 ;
26343 PyObject * obj1 = 0 ;
26344 char * kwnames[] = {
26345 (char *) "self",(char *) "tz", NULL
26346 };
26347
26348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26350 if (!SWIG_IsOK(res1)) {
26351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26352 }
26353 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26354 if (obj1) {
26355 {
26356 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26357 temp2 = true;
26358 }
26359 }
26360 {
26361 PyThreadState* __tstate = wxPyBeginAllowThreads();
26362 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26363 wxPyEndAllowThreads(__tstate);
26364 if (PyErr_Occurred()) SWIG_fail;
26365 }
26366 resultobj = SWIG_From_int(static_cast< int >(result));
26367 {
26368 if (temp2) delete arg2;
26369 }
26370 return resultobj;
26371 fail:
26372 {
26373 if (temp2) delete arg2;
26374 }
26375 return NULL;
26376 }
26377
26378
26379 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26380 PyObject *resultobj = 0;
26381 wxDateTime *arg1 = (wxDateTime *) 0 ;
26382 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26383 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26384 wxDateTime::WeekDay result;
26385 void *argp1 = 0 ;
26386 int res1 = 0 ;
26387 bool temp2 = false ;
26388 PyObject * obj0 = 0 ;
26389 PyObject * obj1 = 0 ;
26390 char * kwnames[] = {
26391 (char *) "self",(char *) "tz", NULL
26392 };
26393
26394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26396 if (!SWIG_IsOK(res1)) {
26397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26398 }
26399 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26400 if (obj1) {
26401 {
26402 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26403 temp2 = true;
26404 }
26405 }
26406 {
26407 PyThreadState* __tstate = wxPyBeginAllowThreads();
26408 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26409 wxPyEndAllowThreads(__tstate);
26410 if (PyErr_Occurred()) SWIG_fail;
26411 }
26412 resultobj = SWIG_From_int(static_cast< int >(result));
26413 {
26414 if (temp2) delete arg2;
26415 }
26416 return resultobj;
26417 fail:
26418 {
26419 if (temp2) delete arg2;
26420 }
26421 return NULL;
26422 }
26423
26424
26425 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26426 PyObject *resultobj = 0;
26427 wxDateTime *arg1 = (wxDateTime *) 0 ;
26428 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26429 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26430 int result;
26431 void *argp1 = 0 ;
26432 int res1 = 0 ;
26433 bool temp2 = false ;
26434 PyObject * obj0 = 0 ;
26435 PyObject * obj1 = 0 ;
26436 char * kwnames[] = {
26437 (char *) "self",(char *) "tz", NULL
26438 };
26439
26440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26442 if (!SWIG_IsOK(res1)) {
26443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26444 }
26445 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26446 if (obj1) {
26447 {
26448 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26449 temp2 = true;
26450 }
26451 }
26452 {
26453 PyThreadState* __tstate = wxPyBeginAllowThreads();
26454 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26455 wxPyEndAllowThreads(__tstate);
26456 if (PyErr_Occurred()) SWIG_fail;
26457 }
26458 resultobj = SWIG_From_int(static_cast< int >(result));
26459 {
26460 if (temp2) delete arg2;
26461 }
26462 return resultobj;
26463 fail:
26464 {
26465 if (temp2) delete arg2;
26466 }
26467 return NULL;
26468 }
26469
26470
26471 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26472 PyObject *resultobj = 0;
26473 wxDateTime *arg1 = (wxDateTime *) 0 ;
26474 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26475 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26476 int result;
26477 void *argp1 = 0 ;
26478 int res1 = 0 ;
26479 bool temp2 = false ;
26480 PyObject * obj0 = 0 ;
26481 PyObject * obj1 = 0 ;
26482 char * kwnames[] = {
26483 (char *) "self",(char *) "tz", NULL
26484 };
26485
26486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26488 if (!SWIG_IsOK(res1)) {
26489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26490 }
26491 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26492 if (obj1) {
26493 {
26494 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26495 temp2 = true;
26496 }
26497 }
26498 {
26499 PyThreadState* __tstate = wxPyBeginAllowThreads();
26500 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26501 wxPyEndAllowThreads(__tstate);
26502 if (PyErr_Occurred()) SWIG_fail;
26503 }
26504 resultobj = SWIG_From_int(static_cast< int >(result));
26505 {
26506 if (temp2) delete arg2;
26507 }
26508 return resultobj;
26509 fail:
26510 {
26511 if (temp2) delete arg2;
26512 }
26513 return NULL;
26514 }
26515
26516
26517 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26518 PyObject *resultobj = 0;
26519 wxDateTime *arg1 = (wxDateTime *) 0 ;
26520 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26521 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26522 int result;
26523 void *argp1 = 0 ;
26524 int res1 = 0 ;
26525 bool temp2 = false ;
26526 PyObject * obj0 = 0 ;
26527 PyObject * obj1 = 0 ;
26528 char * kwnames[] = {
26529 (char *) "self",(char *) "tz", NULL
26530 };
26531
26532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26534 if (!SWIG_IsOK(res1)) {
26535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26536 }
26537 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26538 if (obj1) {
26539 {
26540 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26541 temp2 = true;
26542 }
26543 }
26544 {
26545 PyThreadState* __tstate = wxPyBeginAllowThreads();
26546 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 resultobj = SWIG_From_int(static_cast< int >(result));
26551 {
26552 if (temp2) delete arg2;
26553 }
26554 return resultobj;
26555 fail:
26556 {
26557 if (temp2) delete arg2;
26558 }
26559 return NULL;
26560 }
26561
26562
26563 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26564 PyObject *resultobj = 0;
26565 wxDateTime *arg1 = (wxDateTime *) 0 ;
26566 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26567 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26568 int result;
26569 void *argp1 = 0 ;
26570 int res1 = 0 ;
26571 bool temp2 = false ;
26572 PyObject * obj0 = 0 ;
26573 PyObject * obj1 = 0 ;
26574 char * kwnames[] = {
26575 (char *) "self",(char *) "tz", NULL
26576 };
26577
26578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26580 if (!SWIG_IsOK(res1)) {
26581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26582 }
26583 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26584 if (obj1) {
26585 {
26586 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26587 temp2 = true;
26588 }
26589 }
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 resultobj = SWIG_From_int(static_cast< int >(result));
26597 {
26598 if (temp2) delete arg2;
26599 }
26600 return resultobj;
26601 fail:
26602 {
26603 if (temp2) delete arg2;
26604 }
26605 return NULL;
26606 }
26607
26608
26609 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26610 PyObject *resultobj = 0;
26611 wxDateTime *arg1 = (wxDateTime *) 0 ;
26612 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26613 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26614 int result;
26615 void *argp1 = 0 ;
26616 int res1 = 0 ;
26617 bool temp2 = false ;
26618 PyObject * obj0 = 0 ;
26619 PyObject * obj1 = 0 ;
26620 char * kwnames[] = {
26621 (char *) "self",(char *) "tz", NULL
26622 };
26623
26624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26626 if (!SWIG_IsOK(res1)) {
26627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26628 }
26629 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26630 if (obj1) {
26631 {
26632 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26633 temp2 = true;
26634 }
26635 }
26636 {
26637 PyThreadState* __tstate = wxPyBeginAllowThreads();
26638 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 resultobj = SWIG_From_int(static_cast< int >(result));
26643 {
26644 if (temp2) delete arg2;
26645 }
26646 return resultobj;
26647 fail:
26648 {
26649 if (temp2) delete arg2;
26650 }
26651 return NULL;
26652 }
26653
26654
26655 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26656 PyObject *resultobj = 0;
26657 wxDateTime *arg1 = (wxDateTime *) 0 ;
26658 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26659 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26660 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26661 int result;
26662 void *argp1 = 0 ;
26663 int res1 = 0 ;
26664 int val2 ;
26665 int ecode2 = 0 ;
26666 bool temp3 = false ;
26667 PyObject * obj0 = 0 ;
26668 PyObject * obj1 = 0 ;
26669 PyObject * obj2 = 0 ;
26670 char * kwnames[] = {
26671 (char *) "self",(char *) "flags",(char *) "tz", NULL
26672 };
26673
26674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26676 if (!SWIG_IsOK(res1)) {
26677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26678 }
26679 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26680 if (obj1) {
26681 ecode2 = SWIG_AsVal_int(obj1, &val2);
26682 if (!SWIG_IsOK(ecode2)) {
26683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26684 }
26685 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26686 }
26687 if (obj2) {
26688 {
26689 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26690 temp3 = true;
26691 }
26692 }
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 resultobj = SWIG_From_int(static_cast< int >(result));
26700 {
26701 if (temp3) delete arg3;
26702 }
26703 return resultobj;
26704 fail:
26705 {
26706 if (temp3) delete arg3;
26707 }
26708 return NULL;
26709 }
26710
26711
26712 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26713 PyObject *resultobj = 0;
26714 wxDateTime *arg1 = (wxDateTime *) 0 ;
26715 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26716 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26717 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26718 int result;
26719 void *argp1 = 0 ;
26720 int res1 = 0 ;
26721 int val2 ;
26722 int ecode2 = 0 ;
26723 bool temp3 = false ;
26724 PyObject * obj0 = 0 ;
26725 PyObject * obj1 = 0 ;
26726 PyObject * obj2 = 0 ;
26727 char * kwnames[] = {
26728 (char *) "self",(char *) "flags",(char *) "tz", NULL
26729 };
26730
26731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26733 if (!SWIG_IsOK(res1)) {
26734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26735 }
26736 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26737 if (obj1) {
26738 ecode2 = SWIG_AsVal_int(obj1, &val2);
26739 if (!SWIG_IsOK(ecode2)) {
26740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26741 }
26742 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26743 }
26744 if (obj2) {
26745 {
26746 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26747 temp3 = true;
26748 }
26749 }
26750 {
26751 PyThreadState* __tstate = wxPyBeginAllowThreads();
26752 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26753 wxPyEndAllowThreads(__tstate);
26754 if (PyErr_Occurred()) SWIG_fail;
26755 }
26756 resultobj = SWIG_From_int(static_cast< int >(result));
26757 {
26758 if (temp3) delete arg3;
26759 }
26760 return resultobj;
26761 fail:
26762 {
26763 if (temp3) delete arg3;
26764 }
26765 return NULL;
26766 }
26767
26768
26769 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26770 PyObject *resultobj = 0;
26771 wxDateTime *arg1 = (wxDateTime *) 0 ;
26772 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26773 bool result;
26774 void *argp1 = 0 ;
26775 int res1 = 0 ;
26776 int val2 ;
26777 int ecode2 = 0 ;
26778 PyObject * obj0 = 0 ;
26779 PyObject * obj1 = 0 ;
26780 char * kwnames[] = {
26781 (char *) "self",(char *) "country", NULL
26782 };
26783
26784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26786 if (!SWIG_IsOK(res1)) {
26787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26788 }
26789 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26790 if (obj1) {
26791 ecode2 = SWIG_AsVal_int(obj1, &val2);
26792 if (!SWIG_IsOK(ecode2)) {
26793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26794 }
26795 arg2 = static_cast< wxDateTime::Country >(val2);
26796 }
26797 {
26798 PyThreadState* __tstate = wxPyBeginAllowThreads();
26799 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26800 wxPyEndAllowThreads(__tstate);
26801 if (PyErr_Occurred()) SWIG_fail;
26802 }
26803 {
26804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26805 }
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26813 PyObject *resultobj = 0;
26814 wxDateTime *arg1 = (wxDateTime *) 0 ;
26815 wxDateTime *arg2 = 0 ;
26816 bool result;
26817 void *argp1 = 0 ;
26818 int res1 = 0 ;
26819 void *argp2 = 0 ;
26820 int res2 = 0 ;
26821 PyObject * obj0 = 0 ;
26822 PyObject * obj1 = 0 ;
26823 char * kwnames[] = {
26824 (char *) "self",(char *) "datetime", NULL
26825 };
26826
26827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26829 if (!SWIG_IsOK(res1)) {
26830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26831 }
26832 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26834 if (!SWIG_IsOK(res2)) {
26835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26836 }
26837 if (!argp2) {
26838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26839 }
26840 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26841 {
26842 PyThreadState* __tstate = wxPyBeginAllowThreads();
26843 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26844 wxPyEndAllowThreads(__tstate);
26845 if (PyErr_Occurred()) SWIG_fail;
26846 }
26847 {
26848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26849 }
26850 return resultobj;
26851 fail:
26852 return NULL;
26853 }
26854
26855
26856 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26857 PyObject *resultobj = 0;
26858 wxDateTime *arg1 = (wxDateTime *) 0 ;
26859 wxDateTime *arg2 = 0 ;
26860 bool result;
26861 void *argp1 = 0 ;
26862 int res1 = 0 ;
26863 void *argp2 = 0 ;
26864 int res2 = 0 ;
26865 PyObject * obj0 = 0 ;
26866 PyObject * obj1 = 0 ;
26867 char * kwnames[] = {
26868 (char *) "self",(char *) "datetime", NULL
26869 };
26870
26871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26873 if (!SWIG_IsOK(res1)) {
26874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26875 }
26876 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26877 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26878 if (!SWIG_IsOK(res2)) {
26879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26880 }
26881 if (!argp2) {
26882 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26883 }
26884 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26885 {
26886 PyThreadState* __tstate = wxPyBeginAllowThreads();
26887 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26888 wxPyEndAllowThreads(__tstate);
26889 if (PyErr_Occurred()) SWIG_fail;
26890 }
26891 {
26892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26893 }
26894 return resultobj;
26895 fail:
26896 return NULL;
26897 }
26898
26899
26900 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26901 PyObject *resultobj = 0;
26902 wxDateTime *arg1 = (wxDateTime *) 0 ;
26903 wxDateTime *arg2 = 0 ;
26904 bool result;
26905 void *argp1 = 0 ;
26906 int res1 = 0 ;
26907 void *argp2 = 0 ;
26908 int res2 = 0 ;
26909 PyObject * obj0 = 0 ;
26910 PyObject * obj1 = 0 ;
26911 char * kwnames[] = {
26912 (char *) "self",(char *) "datetime", NULL
26913 };
26914
26915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26917 if (!SWIG_IsOK(res1)) {
26918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26919 }
26920 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26921 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26922 if (!SWIG_IsOK(res2)) {
26923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26924 }
26925 if (!argp2) {
26926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26927 }
26928 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26929 {
26930 PyThreadState* __tstate = wxPyBeginAllowThreads();
26931 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26932 wxPyEndAllowThreads(__tstate);
26933 if (PyErr_Occurred()) SWIG_fail;
26934 }
26935 {
26936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26937 }
26938 return resultobj;
26939 fail:
26940 return NULL;
26941 }
26942
26943
26944 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26945 PyObject *resultobj = 0;
26946 wxDateTime *arg1 = (wxDateTime *) 0 ;
26947 wxDateTime *arg2 = 0 ;
26948 wxDateTime *arg3 = 0 ;
26949 bool result;
26950 void *argp1 = 0 ;
26951 int res1 = 0 ;
26952 void *argp2 = 0 ;
26953 int res2 = 0 ;
26954 void *argp3 = 0 ;
26955 int res3 = 0 ;
26956 PyObject * obj0 = 0 ;
26957 PyObject * obj1 = 0 ;
26958 PyObject * obj2 = 0 ;
26959 char * kwnames[] = {
26960 (char *) "self",(char *) "t1",(char *) "t2", NULL
26961 };
26962
26963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26965 if (!SWIG_IsOK(res1)) {
26966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26967 }
26968 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26970 if (!SWIG_IsOK(res2)) {
26971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26972 }
26973 if (!argp2) {
26974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26975 }
26976 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26977 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26978 if (!SWIG_IsOK(res3)) {
26979 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26980 }
26981 if (!argp3) {
26982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26983 }
26984 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26985 {
26986 PyThreadState* __tstate = wxPyBeginAllowThreads();
26987 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
26988 wxPyEndAllowThreads(__tstate);
26989 if (PyErr_Occurred()) SWIG_fail;
26990 }
26991 {
26992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26993 }
26994 return resultobj;
26995 fail:
26996 return NULL;
26997 }
26998
26999
27000 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27001 PyObject *resultobj = 0;
27002 wxDateTime *arg1 = (wxDateTime *) 0 ;
27003 wxDateTime *arg2 = 0 ;
27004 wxDateTime *arg3 = 0 ;
27005 bool result;
27006 void *argp1 = 0 ;
27007 int res1 = 0 ;
27008 void *argp2 = 0 ;
27009 int res2 = 0 ;
27010 void *argp3 = 0 ;
27011 int res3 = 0 ;
27012 PyObject * obj0 = 0 ;
27013 PyObject * obj1 = 0 ;
27014 PyObject * obj2 = 0 ;
27015 char * kwnames[] = {
27016 (char *) "self",(char *) "t1",(char *) "t2", NULL
27017 };
27018
27019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27021 if (!SWIG_IsOK(res1)) {
27022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27023 }
27024 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27025 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27026 if (!SWIG_IsOK(res2)) {
27027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27028 }
27029 if (!argp2) {
27030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27031 }
27032 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27033 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27034 if (!SWIG_IsOK(res3)) {
27035 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27036 }
27037 if (!argp3) {
27038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27039 }
27040 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27044 wxPyEndAllowThreads(__tstate);
27045 if (PyErr_Occurred()) SWIG_fail;
27046 }
27047 {
27048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27049 }
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj = 0;
27058 wxDateTime *arg1 = (wxDateTime *) 0 ;
27059 wxDateTime *arg2 = 0 ;
27060 bool result;
27061 void *argp1 = 0 ;
27062 int res1 = 0 ;
27063 void *argp2 = 0 ;
27064 int res2 = 0 ;
27065 PyObject * obj0 = 0 ;
27066 PyObject * obj1 = 0 ;
27067 char * kwnames[] = {
27068 (char *) "self",(char *) "dt", NULL
27069 };
27070
27071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27073 if (!SWIG_IsOK(res1)) {
27074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27075 }
27076 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27077 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27078 if (!SWIG_IsOK(res2)) {
27079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27080 }
27081 if (!argp2) {
27082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27083 }
27084 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27088 wxPyEndAllowThreads(__tstate);
27089 if (PyErr_Occurred()) SWIG_fail;
27090 }
27091 {
27092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27093 }
27094 return resultobj;
27095 fail:
27096 return NULL;
27097 }
27098
27099
27100 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27101 PyObject *resultobj = 0;
27102 wxDateTime *arg1 = (wxDateTime *) 0 ;
27103 wxDateTime *arg2 = 0 ;
27104 bool result;
27105 void *argp1 = 0 ;
27106 int res1 = 0 ;
27107 void *argp2 = 0 ;
27108 int res2 = 0 ;
27109 PyObject * obj0 = 0 ;
27110 PyObject * obj1 = 0 ;
27111 char * kwnames[] = {
27112 (char *) "self",(char *) "dt", NULL
27113 };
27114
27115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27117 if (!SWIG_IsOK(res1)) {
27118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27119 }
27120 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27121 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27122 if (!SWIG_IsOK(res2)) {
27123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27124 }
27125 if (!argp2) {
27126 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27127 }
27128 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27129 {
27130 PyThreadState* __tstate = wxPyBeginAllowThreads();
27131 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27132 wxPyEndAllowThreads(__tstate);
27133 if (PyErr_Occurred()) SWIG_fail;
27134 }
27135 {
27136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27137 }
27138 return resultobj;
27139 fail:
27140 return NULL;
27141 }
27142
27143
27144 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27145 PyObject *resultobj = 0;
27146 wxDateTime *arg1 = (wxDateTime *) 0 ;
27147 wxDateTime *arg2 = 0 ;
27148 wxTimeSpan *arg3 = 0 ;
27149 bool result;
27150 void *argp1 = 0 ;
27151 int res1 = 0 ;
27152 void *argp2 = 0 ;
27153 int res2 = 0 ;
27154 void *argp3 = 0 ;
27155 int res3 = 0 ;
27156 PyObject * obj0 = 0 ;
27157 PyObject * obj1 = 0 ;
27158 PyObject * obj2 = 0 ;
27159 char * kwnames[] = {
27160 (char *) "self",(char *) "dt",(char *) "ts", NULL
27161 };
27162
27163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27165 if (!SWIG_IsOK(res1)) {
27166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27167 }
27168 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27170 if (!SWIG_IsOK(res2)) {
27171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27172 }
27173 if (!argp2) {
27174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27175 }
27176 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27177 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27178 if (!SWIG_IsOK(res3)) {
27179 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27180 }
27181 if (!argp3) {
27182 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27183 }
27184 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27185 {
27186 PyThreadState* __tstate = wxPyBeginAllowThreads();
27187 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27188 wxPyEndAllowThreads(__tstate);
27189 if (PyErr_Occurred()) SWIG_fail;
27190 }
27191 {
27192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27193 }
27194 return resultobj;
27195 fail:
27196 return NULL;
27197 }
27198
27199
27200 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27201 PyObject *resultobj = 0;
27202 wxDateTime *arg1 = (wxDateTime *) 0 ;
27203 wxTimeSpan *arg2 = 0 ;
27204 wxDateTime *result = 0 ;
27205 void *argp1 = 0 ;
27206 int res1 = 0 ;
27207 void *argp2 = 0 ;
27208 int res2 = 0 ;
27209 PyObject * obj0 = 0 ;
27210 PyObject * obj1 = 0 ;
27211 char * kwnames[] = {
27212 (char *) "self",(char *) "diff", NULL
27213 };
27214
27215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27217 if (!SWIG_IsOK(res1)) {
27218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27219 }
27220 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27221 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27222 if (!SWIG_IsOK(res2)) {
27223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27224 }
27225 if (!argp2) {
27226 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27227 }
27228 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27229 {
27230 PyThreadState* __tstate = wxPyBeginAllowThreads();
27231 {
27232 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27233 result = (wxDateTime *) &_result_ref;
27234 }
27235 wxPyEndAllowThreads(__tstate);
27236 if (PyErr_Occurred()) SWIG_fail;
27237 }
27238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27239 return resultobj;
27240 fail:
27241 return NULL;
27242 }
27243
27244
27245 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27246 PyObject *resultobj = 0;
27247 wxDateTime *arg1 = (wxDateTime *) 0 ;
27248 wxDateSpan *arg2 = 0 ;
27249 wxDateTime *result = 0 ;
27250 void *argp1 = 0 ;
27251 int res1 = 0 ;
27252 void *argp2 = 0 ;
27253 int res2 = 0 ;
27254 PyObject * obj0 = 0 ;
27255 PyObject * obj1 = 0 ;
27256 char * kwnames[] = {
27257 (char *) "self",(char *) "diff", NULL
27258 };
27259
27260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27262 if (!SWIG_IsOK(res1)) {
27263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27264 }
27265 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27266 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27267 if (!SWIG_IsOK(res2)) {
27268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27269 }
27270 if (!argp2) {
27271 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27272 }
27273 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 {
27277 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27278 result = (wxDateTime *) &_result_ref;
27279 }
27280 wxPyEndAllowThreads(__tstate);
27281 if (PyErr_Occurred()) SWIG_fail;
27282 }
27283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27291 PyObject *resultobj = 0;
27292 wxDateTime *arg1 = (wxDateTime *) 0 ;
27293 wxTimeSpan *arg2 = 0 ;
27294 wxDateTime *result = 0 ;
27295 void *argp1 = 0 ;
27296 int res1 = 0 ;
27297 void *argp2 = 0 ;
27298 int res2 = 0 ;
27299 PyObject * obj0 = 0 ;
27300 PyObject * obj1 = 0 ;
27301 char * kwnames[] = {
27302 (char *) "self",(char *) "diff", NULL
27303 };
27304
27305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27307 if (!SWIG_IsOK(res1)) {
27308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27309 }
27310 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27311 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27312 if (!SWIG_IsOK(res2)) {
27313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27314 }
27315 if (!argp2) {
27316 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27317 }
27318 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27319 {
27320 PyThreadState* __tstate = wxPyBeginAllowThreads();
27321 {
27322 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27323 result = (wxDateTime *) &_result_ref;
27324 }
27325 wxPyEndAllowThreads(__tstate);
27326 if (PyErr_Occurred()) SWIG_fail;
27327 }
27328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27329 return resultobj;
27330 fail:
27331 return NULL;
27332 }
27333
27334
27335 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27336 PyObject *resultobj = 0;
27337 wxDateTime *arg1 = (wxDateTime *) 0 ;
27338 wxDateSpan *arg2 = 0 ;
27339 wxDateTime *result = 0 ;
27340 void *argp1 = 0 ;
27341 int res1 = 0 ;
27342 void *argp2 = 0 ;
27343 int res2 = 0 ;
27344 PyObject * obj0 = 0 ;
27345 PyObject * obj1 = 0 ;
27346 char * kwnames[] = {
27347 (char *) "self",(char *) "diff", NULL
27348 };
27349
27350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27352 if (!SWIG_IsOK(res1)) {
27353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27354 }
27355 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27356 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27357 if (!SWIG_IsOK(res2)) {
27358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27359 }
27360 if (!argp2) {
27361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27362 }
27363 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 {
27367 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27368 result = (wxDateTime *) &_result_ref;
27369 }
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27381 PyObject *resultobj = 0;
27382 wxDateTime *arg1 = (wxDateTime *) 0 ;
27383 wxDateTime *arg2 = 0 ;
27384 wxTimeSpan result;
27385 void *argp1 = 0 ;
27386 int res1 = 0 ;
27387 void *argp2 = 0 ;
27388 int res2 = 0 ;
27389 PyObject * obj0 = 0 ;
27390 PyObject * obj1 = 0 ;
27391 char * kwnames[] = {
27392 (char *) "self",(char *) "dt", NULL
27393 };
27394
27395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27397 if (!SWIG_IsOK(res1)) {
27398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27399 }
27400 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27401 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27402 if (!SWIG_IsOK(res2)) {
27403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27404 }
27405 if (!argp2) {
27406 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27407 }
27408 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27412 wxPyEndAllowThreads(__tstate);
27413 if (PyErr_Occurred()) SWIG_fail;
27414 }
27415 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27416 return resultobj;
27417 fail:
27418 return NULL;
27419 }
27420
27421
27422 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27423 PyObject *resultobj = 0;
27424 wxDateTime *arg1 = (wxDateTime *) 0 ;
27425 wxTimeSpan *arg2 = 0 ;
27426 wxDateTime *result = 0 ;
27427 void *argp1 = 0 ;
27428 int res1 = 0 ;
27429 void *argp2 = 0 ;
27430 int res2 = 0 ;
27431
27432 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27434 if (!SWIG_IsOK(res1)) {
27435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27436 }
27437 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27438 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27439 if (!SWIG_IsOK(res2)) {
27440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27441 }
27442 if (!argp2) {
27443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27444 }
27445 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27446 {
27447 PyThreadState* __tstate = wxPyBeginAllowThreads();
27448 {
27449 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27450 result = (wxDateTime *) &_result_ref;
27451 }
27452 wxPyEndAllowThreads(__tstate);
27453 if (PyErr_Occurred()) SWIG_fail;
27454 }
27455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27456 return resultobj;
27457 fail:
27458 return NULL;
27459 }
27460
27461
27462 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27463 PyObject *resultobj = 0;
27464 wxDateTime *arg1 = (wxDateTime *) 0 ;
27465 wxDateSpan *arg2 = 0 ;
27466 wxDateTime *result = 0 ;
27467 void *argp1 = 0 ;
27468 int res1 = 0 ;
27469 void *argp2 = 0 ;
27470 int res2 = 0 ;
27471
27472 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27474 if (!SWIG_IsOK(res1)) {
27475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27476 }
27477 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27478 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27479 if (!SWIG_IsOK(res2)) {
27480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27481 }
27482 if (!argp2) {
27483 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27484 }
27485 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 {
27489 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27490 result = (wxDateTime *) &_result_ref;
27491 }
27492 wxPyEndAllowThreads(__tstate);
27493 if (PyErr_Occurred()) SWIG_fail;
27494 }
27495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27496 return resultobj;
27497 fail:
27498 return NULL;
27499 }
27500
27501
27502 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27503 int argc;
27504 PyObject *argv[3];
27505
27506 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27507 --argc;
27508 if (argc == 2) {
27509 int _v = 0;
27510 {
27511 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27512 _v = SWIG_CheckState(res);
27513 }
27514 if (!_v) goto check_1;
27515 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27516 }
27517 check_1:
27518
27519 if (argc == 2) {
27520 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27521 }
27522
27523 fail:
27524 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27525 return NULL;
27526 }
27527
27528
27529 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27530 PyObject *resultobj = 0;
27531 wxDateTime *arg1 = (wxDateTime *) 0 ;
27532 wxTimeSpan *arg2 = 0 ;
27533 wxDateTime *result = 0 ;
27534 void *argp1 = 0 ;
27535 int res1 = 0 ;
27536 void *argp2 = 0 ;
27537 int res2 = 0 ;
27538
27539 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27541 if (!SWIG_IsOK(res1)) {
27542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27543 }
27544 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27545 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27546 if (!SWIG_IsOK(res2)) {
27547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27548 }
27549 if (!argp2) {
27550 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27551 }
27552 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27553 {
27554 PyThreadState* __tstate = wxPyBeginAllowThreads();
27555 {
27556 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27557 result = (wxDateTime *) &_result_ref;
27558 }
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27563 return resultobj;
27564 fail:
27565 return NULL;
27566 }
27567
27568
27569 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27570 PyObject *resultobj = 0;
27571 wxDateTime *arg1 = (wxDateTime *) 0 ;
27572 wxDateSpan *arg2 = 0 ;
27573 wxDateTime *result = 0 ;
27574 void *argp1 = 0 ;
27575 int res1 = 0 ;
27576 void *argp2 = 0 ;
27577 int res2 = 0 ;
27578
27579 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27581 if (!SWIG_IsOK(res1)) {
27582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27583 }
27584 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27585 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27586 if (!SWIG_IsOK(res2)) {
27587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27588 }
27589 if (!argp2) {
27590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27591 }
27592 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27593 {
27594 PyThreadState* __tstate = wxPyBeginAllowThreads();
27595 {
27596 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27597 result = (wxDateTime *) &_result_ref;
27598 }
27599 wxPyEndAllowThreads(__tstate);
27600 if (PyErr_Occurred()) SWIG_fail;
27601 }
27602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27603 return resultobj;
27604 fail:
27605 return NULL;
27606 }
27607
27608
27609 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27610 int argc;
27611 PyObject *argv[3];
27612
27613 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27614 --argc;
27615 if (argc == 2) {
27616 int _v = 0;
27617 {
27618 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27619 _v = SWIG_CheckState(res);
27620 }
27621 if (!_v) goto check_1;
27622 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27623 }
27624 check_1:
27625
27626 if (argc == 2) {
27627 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27628 }
27629
27630 fail:
27631 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27632 return NULL;
27633 }
27634
27635
27636 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27637 PyObject *resultobj = 0;
27638 wxDateTime *arg1 = (wxDateTime *) 0 ;
27639 wxTimeSpan *arg2 = 0 ;
27640 wxDateTime result;
27641 void *argp1 = 0 ;
27642 int res1 = 0 ;
27643 void *argp2 = 0 ;
27644 int res2 = 0 ;
27645
27646 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27648 if (!SWIG_IsOK(res1)) {
27649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27650 }
27651 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27652 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27653 if (!SWIG_IsOK(res2)) {
27654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27655 }
27656 if (!argp2) {
27657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27658 }
27659 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27660 {
27661 PyThreadState* __tstate = wxPyBeginAllowThreads();
27662 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27663 wxPyEndAllowThreads(__tstate);
27664 if (PyErr_Occurred()) SWIG_fail;
27665 }
27666 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27667 return resultobj;
27668 fail:
27669 return NULL;
27670 }
27671
27672
27673 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27674 PyObject *resultobj = 0;
27675 wxDateTime *arg1 = (wxDateTime *) 0 ;
27676 wxDateSpan *arg2 = 0 ;
27677 wxDateTime result;
27678 void *argp1 = 0 ;
27679 int res1 = 0 ;
27680 void *argp2 = 0 ;
27681 int res2 = 0 ;
27682
27683 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27685 if (!SWIG_IsOK(res1)) {
27686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27687 }
27688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27689 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27690 if (!SWIG_IsOK(res2)) {
27691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27692 }
27693 if (!argp2) {
27694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27695 }
27696 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27697 {
27698 PyThreadState* __tstate = wxPyBeginAllowThreads();
27699 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27704 return resultobj;
27705 fail:
27706 return NULL;
27707 }
27708
27709
27710 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27711 int argc;
27712 PyObject *argv[3];
27713
27714 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27715 --argc;
27716 if (argc == 2) {
27717 int _v = 0;
27718 {
27719 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27720 _v = SWIG_CheckState(res);
27721 }
27722 if (!_v) goto check_1;
27723 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27724 }
27725 check_1:
27726
27727 if (argc == 2) {
27728 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27729 }
27730
27731 fail:
27732 Py_INCREF(Py_NotImplemented);
27733 return Py_NotImplemented;
27734 }
27735
27736
27737 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27738 PyObject *resultobj = 0;
27739 wxDateTime *arg1 = (wxDateTime *) 0 ;
27740 wxDateTime *arg2 = 0 ;
27741 wxTimeSpan result;
27742 void *argp1 = 0 ;
27743 int res1 = 0 ;
27744 void *argp2 = 0 ;
27745 int res2 = 0 ;
27746
27747 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27749 if (!SWIG_IsOK(res1)) {
27750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27751 }
27752 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27753 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27754 if (!SWIG_IsOK(res2)) {
27755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27756 }
27757 if (!argp2) {
27758 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27759 }
27760 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27761 {
27762 PyThreadState* __tstate = wxPyBeginAllowThreads();
27763 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27764 wxPyEndAllowThreads(__tstate);
27765 if (PyErr_Occurred()) SWIG_fail;
27766 }
27767 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27768 return resultobj;
27769 fail:
27770 return NULL;
27771 }
27772
27773
27774 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27775 PyObject *resultobj = 0;
27776 wxDateTime *arg1 = (wxDateTime *) 0 ;
27777 wxTimeSpan *arg2 = 0 ;
27778 wxDateTime result;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 void *argp2 = 0 ;
27782 int res2 = 0 ;
27783
27784 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27786 if (!SWIG_IsOK(res1)) {
27787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27788 }
27789 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27790 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27791 if (!SWIG_IsOK(res2)) {
27792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27793 }
27794 if (!argp2) {
27795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27796 }
27797 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27798 {
27799 PyThreadState* __tstate = wxPyBeginAllowThreads();
27800 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27801 wxPyEndAllowThreads(__tstate);
27802 if (PyErr_Occurred()) SWIG_fail;
27803 }
27804 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27805 return resultobj;
27806 fail:
27807 return NULL;
27808 }
27809
27810
27811 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27812 PyObject *resultobj = 0;
27813 wxDateTime *arg1 = (wxDateTime *) 0 ;
27814 wxDateSpan *arg2 = 0 ;
27815 wxDateTime result;
27816 void *argp1 = 0 ;
27817 int res1 = 0 ;
27818 void *argp2 = 0 ;
27819 int res2 = 0 ;
27820
27821 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27823 if (!SWIG_IsOK(res1)) {
27824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27825 }
27826 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27827 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27828 if (!SWIG_IsOK(res2)) {
27829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27830 }
27831 if (!argp2) {
27832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27833 }
27834 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27835 {
27836 PyThreadState* __tstate = wxPyBeginAllowThreads();
27837 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27838 wxPyEndAllowThreads(__tstate);
27839 if (PyErr_Occurred()) SWIG_fail;
27840 }
27841 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27842 return resultobj;
27843 fail:
27844 return NULL;
27845 }
27846
27847
27848 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27849 int argc;
27850 PyObject *argv[3];
27851
27852 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27853 --argc;
27854 if (argc == 2) {
27855 int _v = 0;
27856 {
27857 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27858 _v = SWIG_CheckState(res);
27859 }
27860 if (!_v) goto check_1;
27861 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27862 }
27863 check_1:
27864
27865 if (argc == 2) {
27866 int _v = 0;
27867 {
27868 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27869 _v = SWIG_CheckState(res);
27870 }
27871 if (!_v) goto check_2;
27872 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27873 }
27874 check_2:
27875
27876 if (argc == 2) {
27877 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27878 }
27879
27880 fail:
27881 Py_INCREF(Py_NotImplemented);
27882 return Py_NotImplemented;
27883 }
27884
27885
27886 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27887 PyObject *resultobj = 0;
27888 wxDateTime *arg1 = (wxDateTime *) 0 ;
27889 wxDateTime *arg2 = (wxDateTime *) 0 ;
27890 bool result;
27891 void *argp1 = 0 ;
27892 int res1 = 0 ;
27893 void *argp2 = 0 ;
27894 int res2 = 0 ;
27895 PyObject * obj0 = 0 ;
27896 PyObject * obj1 = 0 ;
27897 char * kwnames[] = {
27898 (char *) "self",(char *) "other", NULL
27899 };
27900
27901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27903 if (!SWIG_IsOK(res1)) {
27904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27905 }
27906 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27907 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27908 if (!SWIG_IsOK(res2)) {
27909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27910 }
27911 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27912 {
27913 PyThreadState* __tstate = wxPyBeginAllowThreads();
27914 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27915 wxPyEndAllowThreads(__tstate);
27916 if (PyErr_Occurred()) SWIG_fail;
27917 }
27918 {
27919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27920 }
27921 return resultobj;
27922 fail:
27923 return NULL;
27924 }
27925
27926
27927 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27928 PyObject *resultobj = 0;
27929 wxDateTime *arg1 = (wxDateTime *) 0 ;
27930 wxDateTime *arg2 = (wxDateTime *) 0 ;
27931 bool result;
27932 void *argp1 = 0 ;
27933 int res1 = 0 ;
27934 void *argp2 = 0 ;
27935 int res2 = 0 ;
27936 PyObject * obj0 = 0 ;
27937 PyObject * obj1 = 0 ;
27938 char * kwnames[] = {
27939 (char *) "self",(char *) "other", NULL
27940 };
27941
27942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27944 if (!SWIG_IsOK(res1)) {
27945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27946 }
27947 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27949 if (!SWIG_IsOK(res2)) {
27950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27951 }
27952 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27953 {
27954 PyThreadState* __tstate = wxPyBeginAllowThreads();
27955 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27956 wxPyEndAllowThreads(__tstate);
27957 if (PyErr_Occurred()) SWIG_fail;
27958 }
27959 {
27960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27961 }
27962 return resultobj;
27963 fail:
27964 return NULL;
27965 }
27966
27967
27968 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27969 PyObject *resultobj = 0;
27970 wxDateTime *arg1 = (wxDateTime *) 0 ;
27971 wxDateTime *arg2 = (wxDateTime *) 0 ;
27972 bool result;
27973 void *argp1 = 0 ;
27974 int res1 = 0 ;
27975 void *argp2 = 0 ;
27976 int res2 = 0 ;
27977 PyObject * obj0 = 0 ;
27978 PyObject * obj1 = 0 ;
27979 char * kwnames[] = {
27980 (char *) "self",(char *) "other", NULL
27981 };
27982
27983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27985 if (!SWIG_IsOK(res1)) {
27986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27987 }
27988 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27989 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27990 if (!SWIG_IsOK(res2)) {
27991 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27992 }
27993 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27994 {
27995 PyThreadState* __tstate = wxPyBeginAllowThreads();
27996 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27997 wxPyEndAllowThreads(__tstate);
27998 if (PyErr_Occurred()) SWIG_fail;
27999 }
28000 {
28001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28002 }
28003 return resultobj;
28004 fail:
28005 return NULL;
28006 }
28007
28008
28009 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28010 PyObject *resultobj = 0;
28011 wxDateTime *arg1 = (wxDateTime *) 0 ;
28012 wxDateTime *arg2 = (wxDateTime *) 0 ;
28013 bool result;
28014 void *argp1 = 0 ;
28015 int res1 = 0 ;
28016 void *argp2 = 0 ;
28017 int res2 = 0 ;
28018 PyObject * obj0 = 0 ;
28019 PyObject * obj1 = 0 ;
28020 char * kwnames[] = {
28021 (char *) "self",(char *) "other", NULL
28022 };
28023
28024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28026 if (!SWIG_IsOK(res1)) {
28027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28028 }
28029 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28031 if (!SWIG_IsOK(res2)) {
28032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28033 }
28034 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28035 {
28036 PyThreadState* __tstate = wxPyBeginAllowThreads();
28037 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28038 wxPyEndAllowThreads(__tstate);
28039 if (PyErr_Occurred()) SWIG_fail;
28040 }
28041 {
28042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28043 }
28044 return resultobj;
28045 fail:
28046 return NULL;
28047 }
28048
28049
28050 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28051 PyObject *resultobj = 0;
28052 wxDateTime *arg1 = (wxDateTime *) 0 ;
28053 wxDateTime *arg2 = (wxDateTime *) 0 ;
28054 bool result;
28055 void *argp1 = 0 ;
28056 int res1 = 0 ;
28057 void *argp2 = 0 ;
28058 int res2 = 0 ;
28059 PyObject * obj0 = 0 ;
28060 PyObject * obj1 = 0 ;
28061 char * kwnames[] = {
28062 (char *) "self",(char *) "other", NULL
28063 };
28064
28065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28067 if (!SWIG_IsOK(res1)) {
28068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28069 }
28070 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28071 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28072 if (!SWIG_IsOK(res2)) {
28073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28074 }
28075 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28076 {
28077 PyThreadState* __tstate = wxPyBeginAllowThreads();
28078 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28079 wxPyEndAllowThreads(__tstate);
28080 if (PyErr_Occurred()) SWIG_fail;
28081 }
28082 {
28083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28084 }
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28092 PyObject *resultobj = 0;
28093 wxDateTime *arg1 = (wxDateTime *) 0 ;
28094 wxDateTime *arg2 = (wxDateTime *) 0 ;
28095 bool result;
28096 void *argp1 = 0 ;
28097 int res1 = 0 ;
28098 void *argp2 = 0 ;
28099 int res2 = 0 ;
28100 PyObject * obj0 = 0 ;
28101 PyObject * obj1 = 0 ;
28102 char * kwnames[] = {
28103 (char *) "self",(char *) "other", NULL
28104 };
28105
28106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28108 if (!SWIG_IsOK(res1)) {
28109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28110 }
28111 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28112 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28113 if (!SWIG_IsOK(res2)) {
28114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28115 }
28116 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28117 {
28118 PyThreadState* __tstate = wxPyBeginAllowThreads();
28119 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28120 wxPyEndAllowThreads(__tstate);
28121 if (PyErr_Occurred()) SWIG_fail;
28122 }
28123 {
28124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28125 }
28126 return resultobj;
28127 fail:
28128 return NULL;
28129 }
28130
28131
28132 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj = 0;
28134 wxDateTime *arg1 = (wxDateTime *) 0 ;
28135 wxString *arg2 = 0 ;
28136 int result;
28137 void *argp1 = 0 ;
28138 int res1 = 0 ;
28139 bool temp2 = false ;
28140 PyObject * obj0 = 0 ;
28141 PyObject * obj1 = 0 ;
28142 char * kwnames[] = {
28143 (char *) "self",(char *) "date", NULL
28144 };
28145
28146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28148 if (!SWIG_IsOK(res1)) {
28149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28150 }
28151 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28152 {
28153 arg2 = wxString_in_helper(obj1);
28154 if (arg2 == NULL) SWIG_fail;
28155 temp2 = true;
28156 }
28157 {
28158 PyThreadState* __tstate = wxPyBeginAllowThreads();
28159 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28160 wxPyEndAllowThreads(__tstate);
28161 if (PyErr_Occurred()) SWIG_fail;
28162 }
28163 resultobj = SWIG_From_int(static_cast< int >(result));
28164 {
28165 if (temp2)
28166 delete arg2;
28167 }
28168 return resultobj;
28169 fail:
28170 {
28171 if (temp2)
28172 delete arg2;
28173 }
28174 return NULL;
28175 }
28176
28177
28178 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28179 PyObject *resultobj = 0;
28180 wxDateTime *arg1 = (wxDateTime *) 0 ;
28181 wxString *arg2 = 0 ;
28182 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28183 wxString *arg3 = (wxString *) &arg3_defvalue ;
28184 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28185 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28186 int result;
28187 void *argp1 = 0 ;
28188 int res1 = 0 ;
28189 bool temp2 = false ;
28190 bool temp3 = false ;
28191 void *argp4 = 0 ;
28192 int res4 = 0 ;
28193 PyObject * obj0 = 0 ;
28194 PyObject * obj1 = 0 ;
28195 PyObject * obj2 = 0 ;
28196 PyObject * obj3 = 0 ;
28197 char * kwnames[] = {
28198 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28199 };
28200
28201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28203 if (!SWIG_IsOK(res1)) {
28204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28205 }
28206 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28207 {
28208 arg2 = wxString_in_helper(obj1);
28209 if (arg2 == NULL) SWIG_fail;
28210 temp2 = true;
28211 }
28212 if (obj2) {
28213 {
28214 arg3 = wxString_in_helper(obj2);
28215 if (arg3 == NULL) SWIG_fail;
28216 temp3 = true;
28217 }
28218 }
28219 if (obj3) {
28220 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28221 if (!SWIG_IsOK(res4)) {
28222 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28223 }
28224 if (!argp4) {
28225 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28226 }
28227 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28228 }
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 resultobj = SWIG_From_int(static_cast< int >(result));
28236 {
28237 if (temp2)
28238 delete arg2;
28239 }
28240 {
28241 if (temp3)
28242 delete arg3;
28243 }
28244 return resultobj;
28245 fail:
28246 {
28247 if (temp2)
28248 delete arg2;
28249 }
28250 {
28251 if (temp3)
28252 delete arg3;
28253 }
28254 return NULL;
28255 }
28256
28257
28258 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28259 PyObject *resultobj = 0;
28260 wxDateTime *arg1 = (wxDateTime *) 0 ;
28261 wxString *arg2 = 0 ;
28262 int result;
28263 void *argp1 = 0 ;
28264 int res1 = 0 ;
28265 bool temp2 = false ;
28266 PyObject * obj0 = 0 ;
28267 PyObject * obj1 = 0 ;
28268 char * kwnames[] = {
28269 (char *) "self",(char *) "datetime", NULL
28270 };
28271
28272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28274 if (!SWIG_IsOK(res1)) {
28275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28276 }
28277 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28278 {
28279 arg2 = wxString_in_helper(obj1);
28280 if (arg2 == NULL) SWIG_fail;
28281 temp2 = true;
28282 }
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 resultobj = SWIG_From_int(static_cast< int >(result));
28290 {
28291 if (temp2)
28292 delete arg2;
28293 }
28294 return resultobj;
28295 fail:
28296 {
28297 if (temp2)
28298 delete arg2;
28299 }
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28305 PyObject *resultobj = 0;
28306 wxDateTime *arg1 = (wxDateTime *) 0 ;
28307 wxString *arg2 = 0 ;
28308 int result;
28309 void *argp1 = 0 ;
28310 int res1 = 0 ;
28311 bool temp2 = false ;
28312 PyObject * obj0 = 0 ;
28313 PyObject * obj1 = 0 ;
28314 char * kwnames[] = {
28315 (char *) "self",(char *) "date", NULL
28316 };
28317
28318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28320 if (!SWIG_IsOK(res1)) {
28321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28322 }
28323 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28324 {
28325 arg2 = wxString_in_helper(obj1);
28326 if (arg2 == NULL) SWIG_fail;
28327 temp2 = true;
28328 }
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 resultobj = SWIG_From_int(static_cast< int >(result));
28336 {
28337 if (temp2)
28338 delete arg2;
28339 }
28340 return resultobj;
28341 fail:
28342 {
28343 if (temp2)
28344 delete arg2;
28345 }
28346 return NULL;
28347 }
28348
28349
28350 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28351 PyObject *resultobj = 0;
28352 wxDateTime *arg1 = (wxDateTime *) 0 ;
28353 wxString *arg2 = 0 ;
28354 int result;
28355 void *argp1 = 0 ;
28356 int res1 = 0 ;
28357 bool temp2 = false ;
28358 PyObject * obj0 = 0 ;
28359 PyObject * obj1 = 0 ;
28360 char * kwnames[] = {
28361 (char *) "self",(char *) "time", NULL
28362 };
28363
28364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28366 if (!SWIG_IsOK(res1)) {
28367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28368 }
28369 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28370 {
28371 arg2 = wxString_in_helper(obj1);
28372 if (arg2 == NULL) SWIG_fail;
28373 temp2 = true;
28374 }
28375 {
28376 PyThreadState* __tstate = wxPyBeginAllowThreads();
28377 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28378 wxPyEndAllowThreads(__tstate);
28379 if (PyErr_Occurred()) SWIG_fail;
28380 }
28381 resultobj = SWIG_From_int(static_cast< int >(result));
28382 {
28383 if (temp2)
28384 delete arg2;
28385 }
28386 return resultobj;
28387 fail:
28388 {
28389 if (temp2)
28390 delete arg2;
28391 }
28392 return NULL;
28393 }
28394
28395
28396 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28397 PyObject *resultobj = 0;
28398 wxDateTime *arg1 = (wxDateTime *) 0 ;
28399 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28400 wxString *arg2 = (wxString *) &arg2_defvalue ;
28401 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28402 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28403 wxString result;
28404 void *argp1 = 0 ;
28405 int res1 = 0 ;
28406 bool temp2 = false ;
28407 bool temp3 = false ;
28408 PyObject * obj0 = 0 ;
28409 PyObject * obj1 = 0 ;
28410 PyObject * obj2 = 0 ;
28411 char * kwnames[] = {
28412 (char *) "self",(char *) "format",(char *) "tz", NULL
28413 };
28414
28415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28417 if (!SWIG_IsOK(res1)) {
28418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28419 }
28420 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28421 if (obj1) {
28422 {
28423 arg2 = wxString_in_helper(obj1);
28424 if (arg2 == NULL) SWIG_fail;
28425 temp2 = true;
28426 }
28427 }
28428 if (obj2) {
28429 {
28430 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28431 temp3 = true;
28432 }
28433 }
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28437 wxPyEndAllowThreads(__tstate);
28438 if (PyErr_Occurred()) SWIG_fail;
28439 }
28440 {
28441 #if wxUSE_UNICODE
28442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28443 #else
28444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28445 #endif
28446 }
28447 {
28448 if (temp2)
28449 delete arg2;
28450 }
28451 {
28452 if (temp3) delete arg3;
28453 }
28454 return resultobj;
28455 fail:
28456 {
28457 if (temp2)
28458 delete arg2;
28459 }
28460 {
28461 if (temp3) delete arg3;
28462 }
28463 return NULL;
28464 }
28465
28466
28467 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28468 PyObject *resultobj = 0;
28469 wxDateTime *arg1 = (wxDateTime *) 0 ;
28470 wxString result;
28471 void *argp1 = 0 ;
28472 int res1 = 0 ;
28473 PyObject *swig_obj[1] ;
28474
28475 if (!args) SWIG_fail;
28476 swig_obj[0] = args;
28477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28478 if (!SWIG_IsOK(res1)) {
28479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28480 }
28481 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28482 {
28483 PyThreadState* __tstate = wxPyBeginAllowThreads();
28484 result = ((wxDateTime const *)arg1)->FormatDate();
28485 wxPyEndAllowThreads(__tstate);
28486 if (PyErr_Occurred()) SWIG_fail;
28487 }
28488 {
28489 #if wxUSE_UNICODE
28490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28491 #else
28492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28493 #endif
28494 }
28495 return resultobj;
28496 fail:
28497 return NULL;
28498 }
28499
28500
28501 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28502 PyObject *resultobj = 0;
28503 wxDateTime *arg1 = (wxDateTime *) 0 ;
28504 wxString result;
28505 void *argp1 = 0 ;
28506 int res1 = 0 ;
28507 PyObject *swig_obj[1] ;
28508
28509 if (!args) SWIG_fail;
28510 swig_obj[0] = args;
28511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28512 if (!SWIG_IsOK(res1)) {
28513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28514 }
28515 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28516 {
28517 PyThreadState* __tstate = wxPyBeginAllowThreads();
28518 result = ((wxDateTime const *)arg1)->FormatTime();
28519 wxPyEndAllowThreads(__tstate);
28520 if (PyErr_Occurred()) SWIG_fail;
28521 }
28522 {
28523 #if wxUSE_UNICODE
28524 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28525 #else
28526 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28527 #endif
28528 }
28529 return resultobj;
28530 fail:
28531 return NULL;
28532 }
28533
28534
28535 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28536 PyObject *resultobj = 0;
28537 wxDateTime *arg1 = (wxDateTime *) 0 ;
28538 wxString result;
28539 void *argp1 = 0 ;
28540 int res1 = 0 ;
28541 PyObject *swig_obj[1] ;
28542
28543 if (!args) SWIG_fail;
28544 swig_obj[0] = args;
28545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28546 if (!SWIG_IsOK(res1)) {
28547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28548 }
28549 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28550 {
28551 PyThreadState* __tstate = wxPyBeginAllowThreads();
28552 result = ((wxDateTime const *)arg1)->FormatISODate();
28553 wxPyEndAllowThreads(__tstate);
28554 if (PyErr_Occurred()) SWIG_fail;
28555 }
28556 {
28557 #if wxUSE_UNICODE
28558 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28559 #else
28560 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28561 #endif
28562 }
28563 return resultobj;
28564 fail:
28565 return NULL;
28566 }
28567
28568
28569 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28570 PyObject *resultobj = 0;
28571 wxDateTime *arg1 = (wxDateTime *) 0 ;
28572 wxString result;
28573 void *argp1 = 0 ;
28574 int res1 = 0 ;
28575 PyObject *swig_obj[1] ;
28576
28577 if (!args) SWIG_fail;
28578 swig_obj[0] = args;
28579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28580 if (!SWIG_IsOK(res1)) {
28581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28582 }
28583 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28584 {
28585 PyThreadState* __tstate = wxPyBeginAllowThreads();
28586 result = ((wxDateTime const *)arg1)->FormatISOTime();
28587 wxPyEndAllowThreads(__tstate);
28588 if (PyErr_Occurred()) SWIG_fail;
28589 }
28590 {
28591 #if wxUSE_UNICODE
28592 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28593 #else
28594 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28595 #endif
28596 }
28597 return resultobj;
28598 fail:
28599 return NULL;
28600 }
28601
28602
28603 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28604 PyObject *obj;
28605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28606 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28607 return SWIG_Py_Void();
28608 }
28609
28610 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28611 return SWIG_Python_InitShadowInstance(args);
28612 }
28613
28614 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj = 0;
28616 long arg1 ;
28617 wxTimeSpan result;
28618 long val1 ;
28619 int ecode1 = 0 ;
28620 PyObject * obj0 = 0 ;
28621 char * kwnames[] = {
28622 (char *) "ms", NULL
28623 };
28624
28625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28626 ecode1 = SWIG_AsVal_long(obj0, &val1);
28627 if (!SWIG_IsOK(ecode1)) {
28628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28629 }
28630 arg1 = static_cast< long >(val1);
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 result = wxTimeSpan::Milliseconds(arg1);
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *resultobj = 0;
28646 wxTimeSpan result;
28647
28648 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28649 {
28650 PyThreadState* __tstate = wxPyBeginAllowThreads();
28651 result = wxTimeSpan::Millisecond();
28652 wxPyEndAllowThreads(__tstate);
28653 if (PyErr_Occurred()) SWIG_fail;
28654 }
28655 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28656 return resultobj;
28657 fail:
28658 return NULL;
28659 }
28660
28661
28662 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj = 0;
28664 long arg1 ;
28665 wxTimeSpan result;
28666 long val1 ;
28667 int ecode1 = 0 ;
28668 PyObject * obj0 = 0 ;
28669 char * kwnames[] = {
28670 (char *) "sec", NULL
28671 };
28672
28673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28674 ecode1 = SWIG_AsVal_long(obj0, &val1);
28675 if (!SWIG_IsOK(ecode1)) {
28676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28677 }
28678 arg1 = static_cast< long >(val1);
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 result = wxTimeSpan::Seconds(arg1);
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28693 PyObject *resultobj = 0;
28694 wxTimeSpan result;
28695
28696 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28697 {
28698 PyThreadState* __tstate = wxPyBeginAllowThreads();
28699 result = wxTimeSpan::Second();
28700 wxPyEndAllowThreads(__tstate);
28701 if (PyErr_Occurred()) SWIG_fail;
28702 }
28703 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28704 return resultobj;
28705 fail:
28706 return NULL;
28707 }
28708
28709
28710 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28711 PyObject *resultobj = 0;
28712 long arg1 ;
28713 wxTimeSpan result;
28714 long val1 ;
28715 int ecode1 = 0 ;
28716 PyObject * obj0 = 0 ;
28717 char * kwnames[] = {
28718 (char *) "min", NULL
28719 };
28720
28721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28722 ecode1 = SWIG_AsVal_long(obj0, &val1);
28723 if (!SWIG_IsOK(ecode1)) {
28724 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28725 }
28726 arg1 = static_cast< long >(val1);
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 result = wxTimeSpan::Minutes(arg1);
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28734 return resultobj;
28735 fail:
28736 return NULL;
28737 }
28738
28739
28740 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28741 PyObject *resultobj = 0;
28742 wxTimeSpan result;
28743
28744 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 result = wxTimeSpan::Minute();
28748 wxPyEndAllowThreads(__tstate);
28749 if (PyErr_Occurred()) SWIG_fail;
28750 }
28751 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28759 PyObject *resultobj = 0;
28760 long arg1 ;
28761 wxTimeSpan result;
28762 long val1 ;
28763 int ecode1 = 0 ;
28764 PyObject * obj0 = 0 ;
28765 char * kwnames[] = {
28766 (char *) "hours", NULL
28767 };
28768
28769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28770 ecode1 = SWIG_AsVal_long(obj0, &val1);
28771 if (!SWIG_IsOK(ecode1)) {
28772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28773 }
28774 arg1 = static_cast< long >(val1);
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = wxTimeSpan::Hours(arg1);
28778 wxPyEndAllowThreads(__tstate);
28779 if (PyErr_Occurred()) SWIG_fail;
28780 }
28781 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28782 return resultobj;
28783 fail:
28784 return NULL;
28785 }
28786
28787
28788 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28789 PyObject *resultobj = 0;
28790 wxTimeSpan result;
28791
28792 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 result = wxTimeSpan::Hour();
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28807 PyObject *resultobj = 0;
28808 long arg1 ;
28809 wxTimeSpan result;
28810 long val1 ;
28811 int ecode1 = 0 ;
28812 PyObject * obj0 = 0 ;
28813 char * kwnames[] = {
28814 (char *) "days", NULL
28815 };
28816
28817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28818 ecode1 = SWIG_AsVal_long(obj0, &val1);
28819 if (!SWIG_IsOK(ecode1)) {
28820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28821 }
28822 arg1 = static_cast< long >(val1);
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 result = wxTimeSpan::Days(arg1);
28826 wxPyEndAllowThreads(__tstate);
28827 if (PyErr_Occurred()) SWIG_fail;
28828 }
28829 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28837 PyObject *resultobj = 0;
28838 wxTimeSpan result;
28839
28840 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28841 {
28842 PyThreadState* __tstate = wxPyBeginAllowThreads();
28843 result = wxTimeSpan::Day();
28844 wxPyEndAllowThreads(__tstate);
28845 if (PyErr_Occurred()) SWIG_fail;
28846 }
28847 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28848 return resultobj;
28849 fail:
28850 return NULL;
28851 }
28852
28853
28854 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28855 PyObject *resultobj = 0;
28856 long arg1 ;
28857 wxTimeSpan result;
28858 long val1 ;
28859 int ecode1 = 0 ;
28860 PyObject * obj0 = 0 ;
28861 char * kwnames[] = {
28862 (char *) "days", NULL
28863 };
28864
28865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28866 ecode1 = SWIG_AsVal_long(obj0, &val1);
28867 if (!SWIG_IsOK(ecode1)) {
28868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28869 }
28870 arg1 = static_cast< long >(val1);
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 result = wxTimeSpan::Weeks(arg1);
28874 wxPyEndAllowThreads(__tstate);
28875 if (PyErr_Occurred()) SWIG_fail;
28876 }
28877 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28878 return resultobj;
28879 fail:
28880 return NULL;
28881 }
28882
28883
28884 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28885 PyObject *resultobj = 0;
28886 wxTimeSpan result;
28887
28888 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28889 {
28890 PyThreadState* __tstate = wxPyBeginAllowThreads();
28891 result = wxTimeSpan::Week();
28892 wxPyEndAllowThreads(__tstate);
28893 if (PyErr_Occurred()) SWIG_fail;
28894 }
28895 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28896 return resultobj;
28897 fail:
28898 return NULL;
28899 }
28900
28901
28902 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28903 PyObject *resultobj = 0;
28904 long arg1 = (long) 0 ;
28905 long arg2 = (long) 0 ;
28906 long arg3 = (long) 0 ;
28907 long arg4 = (long) 0 ;
28908 wxTimeSpan *result = 0 ;
28909 long val1 ;
28910 int ecode1 = 0 ;
28911 long val2 ;
28912 int ecode2 = 0 ;
28913 long val3 ;
28914 int ecode3 = 0 ;
28915 long val4 ;
28916 int ecode4 = 0 ;
28917 PyObject * obj0 = 0 ;
28918 PyObject * obj1 = 0 ;
28919 PyObject * obj2 = 0 ;
28920 PyObject * obj3 = 0 ;
28921 char * kwnames[] = {
28922 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28923 };
28924
28925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28926 if (obj0) {
28927 ecode1 = SWIG_AsVal_long(obj0, &val1);
28928 if (!SWIG_IsOK(ecode1)) {
28929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28930 }
28931 arg1 = static_cast< long >(val1);
28932 }
28933 if (obj1) {
28934 ecode2 = SWIG_AsVal_long(obj1, &val2);
28935 if (!SWIG_IsOK(ecode2)) {
28936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28937 }
28938 arg2 = static_cast< long >(val2);
28939 }
28940 if (obj2) {
28941 ecode3 = SWIG_AsVal_long(obj2, &val3);
28942 if (!SWIG_IsOK(ecode3)) {
28943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28944 }
28945 arg3 = static_cast< long >(val3);
28946 }
28947 if (obj3) {
28948 ecode4 = SWIG_AsVal_long(obj3, &val4);
28949 if (!SWIG_IsOK(ecode4)) {
28950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28951 }
28952 arg4 = static_cast< long >(val4);
28953 }
28954 {
28955 PyThreadState* __tstate = wxPyBeginAllowThreads();
28956 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28968 PyObject *resultobj = 0;
28969 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28970 void *argp1 = 0 ;
28971 int res1 = 0 ;
28972 PyObject *swig_obj[1] ;
28973
28974 if (!args) SWIG_fail;
28975 swig_obj[0] = args;
28976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28977 if (!SWIG_IsOK(res1)) {
28978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28979 }
28980 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28981 {
28982 PyThreadState* __tstate = wxPyBeginAllowThreads();
28983 delete arg1;
28984
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 resultobj = SWIG_Py_Void();
28989 return resultobj;
28990 fail:
28991 return NULL;
28992 }
28993
28994
28995 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28996 PyObject *resultobj = 0;
28997 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28998 wxTimeSpan *arg2 = 0 ;
28999 wxTimeSpan *result = 0 ;
29000 void *argp1 = 0 ;
29001 int res1 = 0 ;
29002 void *argp2 = 0 ;
29003 int res2 = 0 ;
29004 PyObject * obj0 = 0 ;
29005 PyObject * obj1 = 0 ;
29006 char * kwnames[] = {
29007 (char *) "self",(char *) "diff", NULL
29008 };
29009
29010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29012 if (!SWIG_IsOK(res1)) {
29013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29014 }
29015 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29016 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29017 if (!SWIG_IsOK(res2)) {
29018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29019 }
29020 if (!argp2) {
29021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29022 }
29023 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29024 {
29025 PyThreadState* __tstate = wxPyBeginAllowThreads();
29026 {
29027 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29028 result = (wxTimeSpan *) &_result_ref;
29029 }
29030 wxPyEndAllowThreads(__tstate);
29031 if (PyErr_Occurred()) SWIG_fail;
29032 }
29033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29034 return resultobj;
29035 fail:
29036 return NULL;
29037 }
29038
29039
29040 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29041 PyObject *resultobj = 0;
29042 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29043 wxTimeSpan *arg2 = 0 ;
29044 wxTimeSpan *result = 0 ;
29045 void *argp1 = 0 ;
29046 int res1 = 0 ;
29047 void *argp2 = 0 ;
29048 int res2 = 0 ;
29049 PyObject * obj0 = 0 ;
29050 PyObject * obj1 = 0 ;
29051 char * kwnames[] = {
29052 (char *) "self",(char *) "diff", NULL
29053 };
29054
29055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29057 if (!SWIG_IsOK(res1)) {
29058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29059 }
29060 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29061 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29062 if (!SWIG_IsOK(res2)) {
29063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29064 }
29065 if (!argp2) {
29066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29067 }
29068 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29069 {
29070 PyThreadState* __tstate = wxPyBeginAllowThreads();
29071 {
29072 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29073 result = (wxTimeSpan *) &_result_ref;
29074 }
29075 wxPyEndAllowThreads(__tstate);
29076 if (PyErr_Occurred()) SWIG_fail;
29077 }
29078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29079 return resultobj;
29080 fail:
29081 return NULL;
29082 }
29083
29084
29085 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29086 PyObject *resultobj = 0;
29087 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29088 int arg2 ;
29089 wxTimeSpan *result = 0 ;
29090 void *argp1 = 0 ;
29091 int res1 = 0 ;
29092 int val2 ;
29093 int ecode2 = 0 ;
29094 PyObject * obj0 = 0 ;
29095 PyObject * obj1 = 0 ;
29096 char * kwnames[] = {
29097 (char *) "self",(char *) "n", NULL
29098 };
29099
29100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29102 if (!SWIG_IsOK(res1)) {
29103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29104 }
29105 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29106 ecode2 = SWIG_AsVal_int(obj1, &val2);
29107 if (!SWIG_IsOK(ecode2)) {
29108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29109 }
29110 arg2 = static_cast< int >(val2);
29111 {
29112 PyThreadState* __tstate = wxPyBeginAllowThreads();
29113 {
29114 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29115 result = (wxTimeSpan *) &_result_ref;
29116 }
29117 wxPyEndAllowThreads(__tstate);
29118 if (PyErr_Occurred()) SWIG_fail;
29119 }
29120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29121 return resultobj;
29122 fail:
29123 return NULL;
29124 }
29125
29126
29127 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29128 PyObject *resultobj = 0;
29129 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29130 wxTimeSpan *result = 0 ;
29131 void *argp1 = 0 ;
29132 int res1 = 0 ;
29133 PyObject *swig_obj[1] ;
29134
29135 if (!args) SWIG_fail;
29136 swig_obj[0] = args;
29137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29138 if (!SWIG_IsOK(res1)) {
29139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29140 }
29141 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29142 {
29143 PyThreadState* __tstate = wxPyBeginAllowThreads();
29144 {
29145 wxTimeSpan &_result_ref = (arg1)->Neg();
29146 result = (wxTimeSpan *) &_result_ref;
29147 }
29148 wxPyEndAllowThreads(__tstate);
29149 if (PyErr_Occurred()) SWIG_fail;
29150 }
29151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29152 return resultobj;
29153 fail:
29154 return NULL;
29155 }
29156
29157
29158 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29159 PyObject *resultobj = 0;
29160 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29161 wxTimeSpan result;
29162 void *argp1 = 0 ;
29163 int res1 = 0 ;
29164 PyObject *swig_obj[1] ;
29165
29166 if (!args) SWIG_fail;
29167 swig_obj[0] = args;
29168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29169 if (!SWIG_IsOK(res1)) {
29170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29171 }
29172 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29173 {
29174 PyThreadState* __tstate = wxPyBeginAllowThreads();
29175 result = ((wxTimeSpan const *)arg1)->Abs();
29176 wxPyEndAllowThreads(__tstate);
29177 if (PyErr_Occurred()) SWIG_fail;
29178 }
29179 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29180 return resultobj;
29181 fail:
29182 return NULL;
29183 }
29184
29185
29186 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29187 PyObject *resultobj = 0;
29188 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29189 wxTimeSpan *arg2 = 0 ;
29190 wxTimeSpan *result = 0 ;
29191 void *argp1 = 0 ;
29192 int res1 = 0 ;
29193 void *argp2 = 0 ;
29194 int res2 = 0 ;
29195 PyObject * obj0 = 0 ;
29196 PyObject * obj1 = 0 ;
29197 char * kwnames[] = {
29198 (char *) "self",(char *) "diff", NULL
29199 };
29200
29201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29203 if (!SWIG_IsOK(res1)) {
29204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29205 }
29206 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29207 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29208 if (!SWIG_IsOK(res2)) {
29209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29210 }
29211 if (!argp2) {
29212 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29213 }
29214 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29215 {
29216 PyThreadState* __tstate = wxPyBeginAllowThreads();
29217 {
29218 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29219 result = (wxTimeSpan *) &_result_ref;
29220 }
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29232 PyObject *resultobj = 0;
29233 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29234 wxTimeSpan *arg2 = 0 ;
29235 wxTimeSpan *result = 0 ;
29236 void *argp1 = 0 ;
29237 int res1 = 0 ;
29238 void *argp2 = 0 ;
29239 int res2 = 0 ;
29240 PyObject * obj0 = 0 ;
29241 PyObject * obj1 = 0 ;
29242 char * kwnames[] = {
29243 (char *) "self",(char *) "diff", NULL
29244 };
29245
29246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29248 if (!SWIG_IsOK(res1)) {
29249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29250 }
29251 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29252 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29253 if (!SWIG_IsOK(res2)) {
29254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29255 }
29256 if (!argp2) {
29257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29258 }
29259 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29260 {
29261 PyThreadState* __tstate = wxPyBeginAllowThreads();
29262 {
29263 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29264 result = (wxTimeSpan *) &_result_ref;
29265 }
29266 wxPyEndAllowThreads(__tstate);
29267 if (PyErr_Occurred()) SWIG_fail;
29268 }
29269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29270 return resultobj;
29271 fail:
29272 return NULL;
29273 }
29274
29275
29276 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29277 PyObject *resultobj = 0;
29278 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29279 int arg2 ;
29280 wxTimeSpan *result = 0 ;
29281 void *argp1 = 0 ;
29282 int res1 = 0 ;
29283 int val2 ;
29284 int ecode2 = 0 ;
29285 PyObject * obj0 = 0 ;
29286 PyObject * obj1 = 0 ;
29287 char * kwnames[] = {
29288 (char *) "self",(char *) "n", NULL
29289 };
29290
29291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29293 if (!SWIG_IsOK(res1)) {
29294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29295 }
29296 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29297 ecode2 = SWIG_AsVal_int(obj1, &val2);
29298 if (!SWIG_IsOK(ecode2)) {
29299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29300 }
29301 arg2 = static_cast< int >(val2);
29302 {
29303 PyThreadState* __tstate = wxPyBeginAllowThreads();
29304 {
29305 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29306 result = (wxTimeSpan *) &_result_ref;
29307 }
29308 wxPyEndAllowThreads(__tstate);
29309 if (PyErr_Occurred()) SWIG_fail;
29310 }
29311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29312 return resultobj;
29313 fail:
29314 return NULL;
29315 }
29316
29317
29318 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29319 PyObject *resultobj = 0;
29320 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29321 wxTimeSpan *result = 0 ;
29322 void *argp1 = 0 ;
29323 int res1 = 0 ;
29324 PyObject *swig_obj[1] ;
29325
29326 if (!args) SWIG_fail;
29327 swig_obj[0] = args;
29328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29329 if (!SWIG_IsOK(res1)) {
29330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29331 }
29332 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29333 {
29334 PyThreadState* __tstate = wxPyBeginAllowThreads();
29335 {
29336 wxTimeSpan &_result_ref = (arg1)->operator -();
29337 result = (wxTimeSpan *) &_result_ref;
29338 }
29339 wxPyEndAllowThreads(__tstate);
29340 if (PyErr_Occurred()) SWIG_fail;
29341 }
29342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29343 return resultobj;
29344 fail:
29345 return NULL;
29346 }
29347
29348
29349 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29350 PyObject *resultobj = 0;
29351 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29352 wxTimeSpan *arg2 = 0 ;
29353 wxTimeSpan result;
29354 void *argp1 = 0 ;
29355 int res1 = 0 ;
29356 void *argp2 = 0 ;
29357 int res2 = 0 ;
29358 PyObject * obj0 = 0 ;
29359 PyObject * obj1 = 0 ;
29360 char * kwnames[] = {
29361 (char *) "self",(char *) "other", NULL
29362 };
29363
29364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29366 if (!SWIG_IsOK(res1)) {
29367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29368 }
29369 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29370 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29371 if (!SWIG_IsOK(res2)) {
29372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29373 }
29374 if (!argp2) {
29375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29376 }
29377 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29381 wxPyEndAllowThreads(__tstate);
29382 if (PyErr_Occurred()) SWIG_fail;
29383 }
29384 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29385 return resultobj;
29386 fail:
29387 return NULL;
29388 }
29389
29390
29391 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29392 PyObject *resultobj = 0;
29393 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29394 wxTimeSpan *arg2 = 0 ;
29395 wxTimeSpan result;
29396 void *argp1 = 0 ;
29397 int res1 = 0 ;
29398 void *argp2 = 0 ;
29399 int res2 = 0 ;
29400 PyObject * obj0 = 0 ;
29401 PyObject * obj1 = 0 ;
29402 char * kwnames[] = {
29403 (char *) "self",(char *) "other", NULL
29404 };
29405
29406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29408 if (!SWIG_IsOK(res1)) {
29409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29410 }
29411 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29412 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29413 if (!SWIG_IsOK(res2)) {
29414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29415 }
29416 if (!argp2) {
29417 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29418 }
29419 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29420 {
29421 PyThreadState* __tstate = wxPyBeginAllowThreads();
29422 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29423 wxPyEndAllowThreads(__tstate);
29424 if (PyErr_Occurred()) SWIG_fail;
29425 }
29426 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29427 return resultobj;
29428 fail:
29429 return NULL;
29430 }
29431
29432
29433 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29434 PyObject *resultobj = 0;
29435 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29436 int arg2 ;
29437 wxTimeSpan result;
29438 void *argp1 = 0 ;
29439 int res1 = 0 ;
29440 int val2 ;
29441 int ecode2 = 0 ;
29442 PyObject * obj0 = 0 ;
29443 PyObject * obj1 = 0 ;
29444 char * kwnames[] = {
29445 (char *) "self",(char *) "n", NULL
29446 };
29447
29448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29450 if (!SWIG_IsOK(res1)) {
29451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29452 }
29453 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29454 ecode2 = SWIG_AsVal_int(obj1, &val2);
29455 if (!SWIG_IsOK(ecode2)) {
29456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29457 }
29458 arg2 = static_cast< int >(val2);
29459 {
29460 PyThreadState* __tstate = wxPyBeginAllowThreads();
29461 result = wxTimeSpan___mul__(arg1,arg2);
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29466 return resultobj;
29467 fail:
29468 return NULL;
29469 }
29470
29471
29472 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29473 PyObject *resultobj = 0;
29474 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29475 int arg2 ;
29476 wxTimeSpan result;
29477 void *argp1 = 0 ;
29478 int res1 = 0 ;
29479 int val2 ;
29480 int ecode2 = 0 ;
29481 PyObject * obj0 = 0 ;
29482 PyObject * obj1 = 0 ;
29483 char * kwnames[] = {
29484 (char *) "self",(char *) "n", NULL
29485 };
29486
29487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29489 if (!SWIG_IsOK(res1)) {
29490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29491 }
29492 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29493 ecode2 = SWIG_AsVal_int(obj1, &val2);
29494 if (!SWIG_IsOK(ecode2)) {
29495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29496 }
29497 arg2 = static_cast< int >(val2);
29498 {
29499 PyThreadState* __tstate = wxPyBeginAllowThreads();
29500 result = wxTimeSpan___rmul__(arg1,arg2);
29501 wxPyEndAllowThreads(__tstate);
29502 if (PyErr_Occurred()) SWIG_fail;
29503 }
29504 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29505 return resultobj;
29506 fail:
29507 return NULL;
29508 }
29509
29510
29511 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29512 PyObject *resultobj = 0;
29513 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29514 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29515 bool result;
29516 void *argp1 = 0 ;
29517 int res1 = 0 ;
29518 void *argp2 = 0 ;
29519 int res2 = 0 ;
29520 PyObject * obj0 = 0 ;
29521 PyObject * obj1 = 0 ;
29522 char * kwnames[] = {
29523 (char *) "self",(char *) "other", NULL
29524 };
29525
29526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29528 if (!SWIG_IsOK(res1)) {
29529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29530 }
29531 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29533 if (!SWIG_IsOK(res2)) {
29534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29535 }
29536 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29537 {
29538 PyThreadState* __tstate = wxPyBeginAllowThreads();
29539 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29540 wxPyEndAllowThreads(__tstate);
29541 if (PyErr_Occurred()) SWIG_fail;
29542 }
29543 {
29544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29545 }
29546 return resultobj;
29547 fail:
29548 return NULL;
29549 }
29550
29551
29552 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29553 PyObject *resultobj = 0;
29554 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29555 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29556 bool result;
29557 void *argp1 = 0 ;
29558 int res1 = 0 ;
29559 void *argp2 = 0 ;
29560 int res2 = 0 ;
29561 PyObject * obj0 = 0 ;
29562 PyObject * obj1 = 0 ;
29563 char * kwnames[] = {
29564 (char *) "self",(char *) "other", NULL
29565 };
29566
29567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29569 if (!SWIG_IsOK(res1)) {
29570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29571 }
29572 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29573 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29574 if (!SWIG_IsOK(res2)) {
29575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29576 }
29577 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29578 {
29579 PyThreadState* __tstate = wxPyBeginAllowThreads();
29580 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29581 wxPyEndAllowThreads(__tstate);
29582 if (PyErr_Occurred()) SWIG_fail;
29583 }
29584 {
29585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29586 }
29587 return resultobj;
29588 fail:
29589 return NULL;
29590 }
29591
29592
29593 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29594 PyObject *resultobj = 0;
29595 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29596 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29597 bool result;
29598 void *argp1 = 0 ;
29599 int res1 = 0 ;
29600 void *argp2 = 0 ;
29601 int res2 = 0 ;
29602 PyObject * obj0 = 0 ;
29603 PyObject * obj1 = 0 ;
29604 char * kwnames[] = {
29605 (char *) "self",(char *) "other", NULL
29606 };
29607
29608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29610 if (!SWIG_IsOK(res1)) {
29611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29612 }
29613 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29614 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29615 if (!SWIG_IsOK(res2)) {
29616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29617 }
29618 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29619 {
29620 PyThreadState* __tstate = wxPyBeginAllowThreads();
29621 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29622 wxPyEndAllowThreads(__tstate);
29623 if (PyErr_Occurred()) SWIG_fail;
29624 }
29625 {
29626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29627 }
29628 return resultobj;
29629 fail:
29630 return NULL;
29631 }
29632
29633
29634 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29635 PyObject *resultobj = 0;
29636 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29637 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29638 bool result;
29639 void *argp1 = 0 ;
29640 int res1 = 0 ;
29641 void *argp2 = 0 ;
29642 int res2 = 0 ;
29643 PyObject * obj0 = 0 ;
29644 PyObject * obj1 = 0 ;
29645 char * kwnames[] = {
29646 (char *) "self",(char *) "other", NULL
29647 };
29648
29649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29651 if (!SWIG_IsOK(res1)) {
29652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29653 }
29654 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29655 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29656 if (!SWIG_IsOK(res2)) {
29657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29658 }
29659 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29660 {
29661 PyThreadState* __tstate = wxPyBeginAllowThreads();
29662 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29663 wxPyEndAllowThreads(__tstate);
29664 if (PyErr_Occurred()) SWIG_fail;
29665 }
29666 {
29667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29668 }
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29676 PyObject *resultobj = 0;
29677 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29678 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29679 bool result;
29680 void *argp1 = 0 ;
29681 int res1 = 0 ;
29682 void *argp2 = 0 ;
29683 int res2 = 0 ;
29684 PyObject * obj0 = 0 ;
29685 PyObject * obj1 = 0 ;
29686 char * kwnames[] = {
29687 (char *) "self",(char *) "other", NULL
29688 };
29689
29690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29692 if (!SWIG_IsOK(res1)) {
29693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29694 }
29695 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29697 if (!SWIG_IsOK(res2)) {
29698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29699 }
29700 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29701 {
29702 PyThreadState* __tstate = wxPyBeginAllowThreads();
29703 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29704 wxPyEndAllowThreads(__tstate);
29705 if (PyErr_Occurred()) SWIG_fail;
29706 }
29707 {
29708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29709 }
29710 return resultobj;
29711 fail:
29712 return NULL;
29713 }
29714
29715
29716 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29717 PyObject *resultobj = 0;
29718 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29719 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29720 bool result;
29721 void *argp1 = 0 ;
29722 int res1 = 0 ;
29723 void *argp2 = 0 ;
29724 int res2 = 0 ;
29725 PyObject * obj0 = 0 ;
29726 PyObject * obj1 = 0 ;
29727 char * kwnames[] = {
29728 (char *) "self",(char *) "other", NULL
29729 };
29730
29731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29733 if (!SWIG_IsOK(res1)) {
29734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29735 }
29736 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29738 if (!SWIG_IsOK(res2)) {
29739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29740 }
29741 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29742 {
29743 PyThreadState* __tstate = wxPyBeginAllowThreads();
29744 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29745 wxPyEndAllowThreads(__tstate);
29746 if (PyErr_Occurred()) SWIG_fail;
29747 }
29748 {
29749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29750 }
29751 return resultobj;
29752 fail:
29753 return NULL;
29754 }
29755
29756
29757 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29758 PyObject *resultobj = 0;
29759 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29760 bool result;
29761 void *argp1 = 0 ;
29762 int res1 = 0 ;
29763 PyObject *swig_obj[1] ;
29764
29765 if (!args) SWIG_fail;
29766 swig_obj[0] = args;
29767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29768 if (!SWIG_IsOK(res1)) {
29769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29770 }
29771 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29775 wxPyEndAllowThreads(__tstate);
29776 if (PyErr_Occurred()) SWIG_fail;
29777 }
29778 {
29779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29780 }
29781 return resultobj;
29782 fail:
29783 return NULL;
29784 }
29785
29786
29787 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29788 PyObject *resultobj = 0;
29789 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29790 bool result;
29791 void *argp1 = 0 ;
29792 int res1 = 0 ;
29793 PyObject *swig_obj[1] ;
29794
29795 if (!args) SWIG_fail;
29796 swig_obj[0] = args;
29797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29798 if (!SWIG_IsOK(res1)) {
29799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29800 }
29801 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 {
29809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29810 }
29811 return resultobj;
29812 fail:
29813 return NULL;
29814 }
29815
29816
29817 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29818 PyObject *resultobj = 0;
29819 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29820 bool result;
29821 void *argp1 = 0 ;
29822 int res1 = 0 ;
29823 PyObject *swig_obj[1] ;
29824
29825 if (!args) SWIG_fail;
29826 swig_obj[0] = args;
29827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29828 if (!SWIG_IsOK(res1)) {
29829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29830 }
29831 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29832 {
29833 PyThreadState* __tstate = wxPyBeginAllowThreads();
29834 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29835 wxPyEndAllowThreads(__tstate);
29836 if (PyErr_Occurred()) SWIG_fail;
29837 }
29838 {
29839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29840 }
29841 return resultobj;
29842 fail:
29843 return NULL;
29844 }
29845
29846
29847 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29848 PyObject *resultobj = 0;
29849 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29850 wxTimeSpan *arg2 = 0 ;
29851 bool result;
29852 void *argp1 = 0 ;
29853 int res1 = 0 ;
29854 void *argp2 = 0 ;
29855 int res2 = 0 ;
29856 PyObject * obj0 = 0 ;
29857 PyObject * obj1 = 0 ;
29858 char * kwnames[] = {
29859 (char *) "self",(char *) "ts", NULL
29860 };
29861
29862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29864 if (!SWIG_IsOK(res1)) {
29865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29866 }
29867 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29868 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29869 if (!SWIG_IsOK(res2)) {
29870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29871 }
29872 if (!argp2) {
29873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29874 }
29875 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29876 {
29877 PyThreadState* __tstate = wxPyBeginAllowThreads();
29878 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29879 wxPyEndAllowThreads(__tstate);
29880 if (PyErr_Occurred()) SWIG_fail;
29881 }
29882 {
29883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29884 }
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29892 PyObject *resultobj = 0;
29893 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29894 wxTimeSpan *arg2 = 0 ;
29895 bool result;
29896 void *argp1 = 0 ;
29897 int res1 = 0 ;
29898 void *argp2 = 0 ;
29899 int res2 = 0 ;
29900 PyObject * obj0 = 0 ;
29901 PyObject * obj1 = 0 ;
29902 char * kwnames[] = {
29903 (char *) "self",(char *) "ts", NULL
29904 };
29905
29906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29908 if (!SWIG_IsOK(res1)) {
29909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29910 }
29911 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29912 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29913 if (!SWIG_IsOK(res2)) {
29914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29915 }
29916 if (!argp2) {
29917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29918 }
29919 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29920 {
29921 PyThreadState* __tstate = wxPyBeginAllowThreads();
29922 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29923 wxPyEndAllowThreads(__tstate);
29924 if (PyErr_Occurred()) SWIG_fail;
29925 }
29926 {
29927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29928 }
29929 return resultobj;
29930 fail:
29931 return NULL;
29932 }
29933
29934
29935 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29936 PyObject *resultobj = 0;
29937 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29938 wxTimeSpan *arg2 = 0 ;
29939 bool result;
29940 void *argp1 = 0 ;
29941 int res1 = 0 ;
29942 void *argp2 = 0 ;
29943 int res2 = 0 ;
29944 PyObject * obj0 = 0 ;
29945 PyObject * obj1 = 0 ;
29946 char * kwnames[] = {
29947 (char *) "self",(char *) "t", NULL
29948 };
29949
29950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29952 if (!SWIG_IsOK(res1)) {
29953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29954 }
29955 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29956 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29957 if (!SWIG_IsOK(res2)) {
29958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29959 }
29960 if (!argp2) {
29961 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29962 }
29963 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29964 {
29965 PyThreadState* __tstate = wxPyBeginAllowThreads();
29966 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29967 wxPyEndAllowThreads(__tstate);
29968 if (PyErr_Occurred()) SWIG_fail;
29969 }
29970 {
29971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29972 }
29973 return resultobj;
29974 fail:
29975 return NULL;
29976 }
29977
29978
29979 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29980 PyObject *resultobj = 0;
29981 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29982 int result;
29983 void *argp1 = 0 ;
29984 int res1 = 0 ;
29985 PyObject *swig_obj[1] ;
29986
29987 if (!args) SWIG_fail;
29988 swig_obj[0] = args;
29989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29990 if (!SWIG_IsOK(res1)) {
29991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29992 }
29993 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29994 {
29995 PyThreadState* __tstate = wxPyBeginAllowThreads();
29996 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29997 wxPyEndAllowThreads(__tstate);
29998 if (PyErr_Occurred()) SWIG_fail;
29999 }
30000 resultobj = SWIG_From_int(static_cast< int >(result));
30001 return resultobj;
30002 fail:
30003 return NULL;
30004 }
30005
30006
30007 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30008 PyObject *resultobj = 0;
30009 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30010 int result;
30011 void *argp1 = 0 ;
30012 int res1 = 0 ;
30013 PyObject *swig_obj[1] ;
30014
30015 if (!args) SWIG_fail;
30016 swig_obj[0] = args;
30017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30018 if (!SWIG_IsOK(res1)) {
30019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30020 }
30021 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30022 {
30023 PyThreadState* __tstate = wxPyBeginAllowThreads();
30024 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30025 wxPyEndAllowThreads(__tstate);
30026 if (PyErr_Occurred()) SWIG_fail;
30027 }
30028 resultobj = SWIG_From_int(static_cast< int >(result));
30029 return resultobj;
30030 fail:
30031 return NULL;
30032 }
30033
30034
30035 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30036 PyObject *resultobj = 0;
30037 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30038 int result;
30039 void *argp1 = 0 ;
30040 int res1 = 0 ;
30041 PyObject *swig_obj[1] ;
30042
30043 if (!args) SWIG_fail;
30044 swig_obj[0] = args;
30045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30046 if (!SWIG_IsOK(res1)) {
30047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30048 }
30049 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30050 {
30051 PyThreadState* __tstate = wxPyBeginAllowThreads();
30052 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30053 wxPyEndAllowThreads(__tstate);
30054 if (PyErr_Occurred()) SWIG_fail;
30055 }
30056 resultobj = SWIG_From_int(static_cast< int >(result));
30057 return resultobj;
30058 fail:
30059 return NULL;
30060 }
30061
30062
30063 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30064 PyObject *resultobj = 0;
30065 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30066 int result;
30067 void *argp1 = 0 ;
30068 int res1 = 0 ;
30069 PyObject *swig_obj[1] ;
30070
30071 if (!args) SWIG_fail;
30072 swig_obj[0] = args;
30073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30074 if (!SWIG_IsOK(res1)) {
30075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30076 }
30077 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30078 {
30079 PyThreadState* __tstate = wxPyBeginAllowThreads();
30080 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30081 wxPyEndAllowThreads(__tstate);
30082 if (PyErr_Occurred()) SWIG_fail;
30083 }
30084 resultobj = SWIG_From_int(static_cast< int >(result));
30085 return resultobj;
30086 fail:
30087 return NULL;
30088 }
30089
30090
30091 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30092 PyObject *resultobj = 0;
30093 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30094 wxLongLong result;
30095 void *argp1 = 0 ;
30096 int res1 = 0 ;
30097 PyObject *swig_obj[1] ;
30098
30099 if (!args) SWIG_fail;
30100 swig_obj[0] = args;
30101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30102 if (!SWIG_IsOK(res1)) {
30103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30104 }
30105 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30106 {
30107 PyThreadState* __tstate = wxPyBeginAllowThreads();
30108 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 {
30113 PyObject *hi, *lo, *shifter, *shifted;
30114 hi = PyLong_FromLong( (&result)->GetHi() );
30115 lo = PyLong_FromLong( (&result)->GetLo() );
30116 shifter = PyLong_FromLong(32);
30117 shifted = PyNumber_Lshift(hi, shifter);
30118 resultobj = PyNumber_Or(shifted, lo);
30119 Py_DECREF(hi);
30120 Py_DECREF(lo);
30121 Py_DECREF(shifter);
30122 Py_DECREF(shifted);
30123 }
30124 return resultobj;
30125 fail:
30126 return NULL;
30127 }
30128
30129
30130 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30131 PyObject *resultobj = 0;
30132 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30133 wxLongLong result;
30134 void *argp1 = 0 ;
30135 int res1 = 0 ;
30136 PyObject *swig_obj[1] ;
30137
30138 if (!args) SWIG_fail;
30139 swig_obj[0] = args;
30140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30141 if (!SWIG_IsOK(res1)) {
30142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30143 }
30144 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30145 {
30146 PyThreadState* __tstate = wxPyBeginAllowThreads();
30147 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30148 wxPyEndAllowThreads(__tstate);
30149 if (PyErr_Occurred()) SWIG_fail;
30150 }
30151 {
30152 PyObject *hi, *lo, *shifter, *shifted;
30153 hi = PyLong_FromLong( (&result)->GetHi() );
30154 lo = PyLong_FromLong( (&result)->GetLo() );
30155 shifter = PyLong_FromLong(32);
30156 shifted = PyNumber_Lshift(hi, shifter);
30157 resultobj = PyNumber_Or(shifted, lo);
30158 Py_DECREF(hi);
30159 Py_DECREF(lo);
30160 Py_DECREF(shifter);
30161 Py_DECREF(shifted);
30162 }
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30170 PyObject *resultobj = 0;
30171 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30172 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30173 wxString *arg2 = (wxString *) &arg2_defvalue ;
30174 wxString result;
30175 void *argp1 = 0 ;
30176 int res1 = 0 ;
30177 bool temp2 = false ;
30178 PyObject * obj0 = 0 ;
30179 PyObject * obj1 = 0 ;
30180 char * kwnames[] = {
30181 (char *) "self",(char *) "format", NULL
30182 };
30183
30184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30186 if (!SWIG_IsOK(res1)) {
30187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30188 }
30189 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30190 if (obj1) {
30191 {
30192 arg2 = wxString_in_helper(obj1);
30193 if (arg2 == NULL) SWIG_fail;
30194 temp2 = true;
30195 }
30196 }
30197 {
30198 PyThreadState* __tstate = wxPyBeginAllowThreads();
30199 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30200 wxPyEndAllowThreads(__tstate);
30201 if (PyErr_Occurred()) SWIG_fail;
30202 }
30203 {
30204 #if wxUSE_UNICODE
30205 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30206 #else
30207 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30208 #endif
30209 }
30210 {
30211 if (temp2)
30212 delete arg2;
30213 }
30214 return resultobj;
30215 fail:
30216 {
30217 if (temp2)
30218 delete arg2;
30219 }
30220 return NULL;
30221 }
30222
30223
30224 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30225 PyObject *obj;
30226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30227 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30228 return SWIG_Py_Void();
30229 }
30230
30231 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30232 return SWIG_Python_InitShadowInstance(args);
30233 }
30234
30235 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30236 PyObject *resultobj = 0;
30237 int arg1 = (int) 0 ;
30238 int arg2 = (int) 0 ;
30239 int arg3 = (int) 0 ;
30240 int arg4 = (int) 0 ;
30241 wxDateSpan *result = 0 ;
30242 int val1 ;
30243 int ecode1 = 0 ;
30244 int val2 ;
30245 int ecode2 = 0 ;
30246 int val3 ;
30247 int ecode3 = 0 ;
30248 int val4 ;
30249 int ecode4 = 0 ;
30250 PyObject * obj0 = 0 ;
30251 PyObject * obj1 = 0 ;
30252 PyObject * obj2 = 0 ;
30253 PyObject * obj3 = 0 ;
30254 char * kwnames[] = {
30255 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30256 };
30257
30258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30259 if (obj0) {
30260 ecode1 = SWIG_AsVal_int(obj0, &val1);
30261 if (!SWIG_IsOK(ecode1)) {
30262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30263 }
30264 arg1 = static_cast< int >(val1);
30265 }
30266 if (obj1) {
30267 ecode2 = SWIG_AsVal_int(obj1, &val2);
30268 if (!SWIG_IsOK(ecode2)) {
30269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30270 }
30271 arg2 = static_cast< int >(val2);
30272 }
30273 if (obj2) {
30274 ecode3 = SWIG_AsVal_int(obj2, &val3);
30275 if (!SWIG_IsOK(ecode3)) {
30276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30277 }
30278 arg3 = static_cast< int >(val3);
30279 }
30280 if (obj3) {
30281 ecode4 = SWIG_AsVal_int(obj3, &val4);
30282 if (!SWIG_IsOK(ecode4)) {
30283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30284 }
30285 arg4 = static_cast< int >(val4);
30286 }
30287 {
30288 PyThreadState* __tstate = wxPyBeginAllowThreads();
30289 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30290 wxPyEndAllowThreads(__tstate);
30291 if (PyErr_Occurred()) SWIG_fail;
30292 }
30293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30294 return resultobj;
30295 fail:
30296 return NULL;
30297 }
30298
30299
30300 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30301 PyObject *resultobj = 0;
30302 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30303 void *argp1 = 0 ;
30304 int res1 = 0 ;
30305 PyObject *swig_obj[1] ;
30306
30307 if (!args) SWIG_fail;
30308 swig_obj[0] = args;
30309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30310 if (!SWIG_IsOK(res1)) {
30311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30312 }
30313 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30314 {
30315 PyThreadState* __tstate = wxPyBeginAllowThreads();
30316 delete arg1;
30317
30318 wxPyEndAllowThreads(__tstate);
30319 if (PyErr_Occurred()) SWIG_fail;
30320 }
30321 resultobj = SWIG_Py_Void();
30322 return resultobj;
30323 fail:
30324 return NULL;
30325 }
30326
30327
30328 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30329 PyObject *resultobj = 0;
30330 int arg1 ;
30331 wxDateSpan result;
30332 int val1 ;
30333 int ecode1 = 0 ;
30334 PyObject * obj0 = 0 ;
30335 char * kwnames[] = {
30336 (char *) "days", NULL
30337 };
30338
30339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30340 ecode1 = SWIG_AsVal_int(obj0, &val1);
30341 if (!SWIG_IsOK(ecode1)) {
30342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30343 }
30344 arg1 = static_cast< int >(val1);
30345 {
30346 PyThreadState* __tstate = wxPyBeginAllowThreads();
30347 result = wxDateSpan::Days(arg1);
30348 wxPyEndAllowThreads(__tstate);
30349 if (PyErr_Occurred()) SWIG_fail;
30350 }
30351 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30352 return resultobj;
30353 fail:
30354 return NULL;
30355 }
30356
30357
30358 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30359 PyObject *resultobj = 0;
30360 wxDateSpan result;
30361
30362 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 result = wxDateSpan::Day();
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30370 return resultobj;
30371 fail:
30372 return NULL;
30373 }
30374
30375
30376 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30377 PyObject *resultobj = 0;
30378 int arg1 ;
30379 wxDateSpan result;
30380 int val1 ;
30381 int ecode1 = 0 ;
30382 PyObject * obj0 = 0 ;
30383 char * kwnames[] = {
30384 (char *) "weeks", NULL
30385 };
30386
30387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30388 ecode1 = SWIG_AsVal_int(obj0, &val1);
30389 if (!SWIG_IsOK(ecode1)) {
30390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30391 }
30392 arg1 = static_cast< int >(val1);
30393 {
30394 PyThreadState* __tstate = wxPyBeginAllowThreads();
30395 result = wxDateSpan::Weeks(arg1);
30396 wxPyEndAllowThreads(__tstate);
30397 if (PyErr_Occurred()) SWIG_fail;
30398 }
30399 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30400 return resultobj;
30401 fail:
30402 return NULL;
30403 }
30404
30405
30406 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30407 PyObject *resultobj = 0;
30408 wxDateSpan result;
30409
30410 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30411 {
30412 PyThreadState* __tstate = wxPyBeginAllowThreads();
30413 result = wxDateSpan::Week();
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30425 PyObject *resultobj = 0;
30426 int arg1 ;
30427 wxDateSpan result;
30428 int val1 ;
30429 int ecode1 = 0 ;
30430 PyObject * obj0 = 0 ;
30431 char * kwnames[] = {
30432 (char *) "mon", NULL
30433 };
30434
30435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30436 ecode1 = SWIG_AsVal_int(obj0, &val1);
30437 if (!SWIG_IsOK(ecode1)) {
30438 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30439 }
30440 arg1 = static_cast< int >(val1);
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 result = wxDateSpan::Months(arg1);
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30448 return resultobj;
30449 fail:
30450 return NULL;
30451 }
30452
30453
30454 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30455 PyObject *resultobj = 0;
30456 wxDateSpan result;
30457
30458 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30459 {
30460 PyThreadState* __tstate = wxPyBeginAllowThreads();
30461 result = wxDateSpan::Month();
30462 wxPyEndAllowThreads(__tstate);
30463 if (PyErr_Occurred()) SWIG_fail;
30464 }
30465 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30466 return resultobj;
30467 fail:
30468 return NULL;
30469 }
30470
30471
30472 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30473 PyObject *resultobj = 0;
30474 int arg1 ;
30475 wxDateSpan result;
30476 int val1 ;
30477 int ecode1 = 0 ;
30478 PyObject * obj0 = 0 ;
30479 char * kwnames[] = {
30480 (char *) "years", NULL
30481 };
30482
30483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30484 ecode1 = SWIG_AsVal_int(obj0, &val1);
30485 if (!SWIG_IsOK(ecode1)) {
30486 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30487 }
30488 arg1 = static_cast< int >(val1);
30489 {
30490 PyThreadState* __tstate = wxPyBeginAllowThreads();
30491 result = wxDateSpan::Years(arg1);
30492 wxPyEndAllowThreads(__tstate);
30493 if (PyErr_Occurred()) SWIG_fail;
30494 }
30495 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30496 return resultobj;
30497 fail:
30498 return NULL;
30499 }
30500
30501
30502 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30503 PyObject *resultobj = 0;
30504 wxDateSpan result;
30505
30506 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30507 {
30508 PyThreadState* __tstate = wxPyBeginAllowThreads();
30509 result = wxDateSpan::Year();
30510 wxPyEndAllowThreads(__tstate);
30511 if (PyErr_Occurred()) SWIG_fail;
30512 }
30513 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30514 return resultobj;
30515 fail:
30516 return NULL;
30517 }
30518
30519
30520 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30521 PyObject *resultobj = 0;
30522 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30523 int arg2 ;
30524 wxDateSpan *result = 0 ;
30525 void *argp1 = 0 ;
30526 int res1 = 0 ;
30527 int val2 ;
30528 int ecode2 = 0 ;
30529 PyObject * obj0 = 0 ;
30530 PyObject * obj1 = 0 ;
30531 char * kwnames[] = {
30532 (char *) "self",(char *) "n", NULL
30533 };
30534
30535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30537 if (!SWIG_IsOK(res1)) {
30538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30539 }
30540 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30541 ecode2 = SWIG_AsVal_int(obj1, &val2);
30542 if (!SWIG_IsOK(ecode2)) {
30543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30544 }
30545 arg2 = static_cast< int >(val2);
30546 {
30547 PyThreadState* __tstate = wxPyBeginAllowThreads();
30548 {
30549 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30550 result = (wxDateSpan *) &_result_ref;
30551 }
30552 wxPyEndAllowThreads(__tstate);
30553 if (PyErr_Occurred()) SWIG_fail;
30554 }
30555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30556 return resultobj;
30557 fail:
30558 return NULL;
30559 }
30560
30561
30562 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30563 PyObject *resultobj = 0;
30564 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30565 int arg2 ;
30566 wxDateSpan *result = 0 ;
30567 void *argp1 = 0 ;
30568 int res1 = 0 ;
30569 int val2 ;
30570 int ecode2 = 0 ;
30571 PyObject * obj0 = 0 ;
30572 PyObject * obj1 = 0 ;
30573 char * kwnames[] = {
30574 (char *) "self",(char *) "n", NULL
30575 };
30576
30577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30579 if (!SWIG_IsOK(res1)) {
30580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30581 }
30582 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30583 ecode2 = SWIG_AsVal_int(obj1, &val2);
30584 if (!SWIG_IsOK(ecode2)) {
30585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30586 }
30587 arg2 = static_cast< int >(val2);
30588 {
30589 PyThreadState* __tstate = wxPyBeginAllowThreads();
30590 {
30591 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30592 result = (wxDateSpan *) &_result_ref;
30593 }
30594 wxPyEndAllowThreads(__tstate);
30595 if (PyErr_Occurred()) SWIG_fail;
30596 }
30597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30605 PyObject *resultobj = 0;
30606 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30607 int arg2 ;
30608 wxDateSpan *result = 0 ;
30609 void *argp1 = 0 ;
30610 int res1 = 0 ;
30611 int val2 ;
30612 int ecode2 = 0 ;
30613 PyObject * obj0 = 0 ;
30614 PyObject * obj1 = 0 ;
30615 char * kwnames[] = {
30616 (char *) "self",(char *) "n", NULL
30617 };
30618
30619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30621 if (!SWIG_IsOK(res1)) {
30622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30623 }
30624 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30625 ecode2 = SWIG_AsVal_int(obj1, &val2);
30626 if (!SWIG_IsOK(ecode2)) {
30627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30628 }
30629 arg2 = static_cast< int >(val2);
30630 {
30631 PyThreadState* __tstate = wxPyBeginAllowThreads();
30632 {
30633 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30634 result = (wxDateSpan *) &_result_ref;
30635 }
30636 wxPyEndAllowThreads(__tstate);
30637 if (PyErr_Occurred()) SWIG_fail;
30638 }
30639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30640 return resultobj;
30641 fail:
30642 return NULL;
30643 }
30644
30645
30646 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30647 PyObject *resultobj = 0;
30648 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30649 int arg2 ;
30650 wxDateSpan *result = 0 ;
30651 void *argp1 = 0 ;
30652 int res1 = 0 ;
30653 int val2 ;
30654 int ecode2 = 0 ;
30655 PyObject * obj0 = 0 ;
30656 PyObject * obj1 = 0 ;
30657 char * kwnames[] = {
30658 (char *) "self",(char *) "n", NULL
30659 };
30660
30661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30663 if (!SWIG_IsOK(res1)) {
30664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30665 }
30666 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30667 ecode2 = SWIG_AsVal_int(obj1, &val2);
30668 if (!SWIG_IsOK(ecode2)) {
30669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30670 }
30671 arg2 = static_cast< int >(val2);
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 {
30675 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30676 result = (wxDateSpan *) &_result_ref;
30677 }
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30689 PyObject *resultobj = 0;
30690 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30691 int result;
30692 void *argp1 = 0 ;
30693 int res1 = 0 ;
30694 PyObject *swig_obj[1] ;
30695
30696 if (!args) SWIG_fail;
30697 swig_obj[0] = args;
30698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30699 if (!SWIG_IsOK(res1)) {
30700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30701 }
30702 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 result = (int)((wxDateSpan const *)arg1)->GetYears();
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_From_int(static_cast< int >(result));
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30717 PyObject *resultobj = 0;
30718 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30719 int result;
30720 void *argp1 = 0 ;
30721 int res1 = 0 ;
30722 PyObject *swig_obj[1] ;
30723
30724 if (!args) SWIG_fail;
30725 swig_obj[0] = args;
30726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30727 if (!SWIG_IsOK(res1)) {
30728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30729 }
30730 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30731 {
30732 PyThreadState* __tstate = wxPyBeginAllowThreads();
30733 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 resultobj = SWIG_From_int(static_cast< int >(result));
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30745 PyObject *resultobj = 0;
30746 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30747 int result;
30748 void *argp1 = 0 ;
30749 int res1 = 0 ;
30750 PyObject *swig_obj[1] ;
30751
30752 if (!args) SWIG_fail;
30753 swig_obj[0] = args;
30754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30755 if (!SWIG_IsOK(res1)) {
30756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30757 }
30758 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30759 {
30760 PyThreadState* __tstate = wxPyBeginAllowThreads();
30761 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30762 wxPyEndAllowThreads(__tstate);
30763 if (PyErr_Occurred()) SWIG_fail;
30764 }
30765 resultobj = SWIG_From_int(static_cast< int >(result));
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30773 PyObject *resultobj = 0;
30774 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30775 int result;
30776 void *argp1 = 0 ;
30777 int res1 = 0 ;
30778 PyObject *swig_obj[1] ;
30779
30780 if (!args) SWIG_fail;
30781 swig_obj[0] = args;
30782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30783 if (!SWIG_IsOK(res1)) {
30784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30785 }
30786 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30787 {
30788 PyThreadState* __tstate = wxPyBeginAllowThreads();
30789 result = (int)((wxDateSpan const *)arg1)->GetDays();
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 resultobj = SWIG_From_int(static_cast< int >(result));
30794 return resultobj;
30795 fail:
30796 return NULL;
30797 }
30798
30799
30800 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30801 PyObject *resultobj = 0;
30802 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30803 int result;
30804 void *argp1 = 0 ;
30805 int res1 = 0 ;
30806 PyObject *swig_obj[1] ;
30807
30808 if (!args) SWIG_fail;
30809 swig_obj[0] = args;
30810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30811 if (!SWIG_IsOK(res1)) {
30812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30813 }
30814 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 resultobj = SWIG_From_int(static_cast< int >(result));
30822 return resultobj;
30823 fail:
30824 return NULL;
30825 }
30826
30827
30828 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30829 PyObject *resultobj = 0;
30830 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30831 wxDateSpan *arg2 = 0 ;
30832 wxDateSpan *result = 0 ;
30833 void *argp1 = 0 ;
30834 int res1 = 0 ;
30835 void *argp2 = 0 ;
30836 int res2 = 0 ;
30837 PyObject * obj0 = 0 ;
30838 PyObject * obj1 = 0 ;
30839 char * kwnames[] = {
30840 (char *) "self",(char *) "other", NULL
30841 };
30842
30843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30845 if (!SWIG_IsOK(res1)) {
30846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30847 }
30848 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30849 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30850 if (!SWIG_IsOK(res2)) {
30851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30852 }
30853 if (!argp2) {
30854 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30855 }
30856 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30857 {
30858 PyThreadState* __tstate = wxPyBeginAllowThreads();
30859 {
30860 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30861 result = (wxDateSpan *) &_result_ref;
30862 }
30863 wxPyEndAllowThreads(__tstate);
30864 if (PyErr_Occurred()) SWIG_fail;
30865 }
30866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30867 return resultobj;
30868 fail:
30869 return NULL;
30870 }
30871
30872
30873 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30874 PyObject *resultobj = 0;
30875 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30876 wxDateSpan *arg2 = 0 ;
30877 wxDateSpan *result = 0 ;
30878 void *argp1 = 0 ;
30879 int res1 = 0 ;
30880 void *argp2 = 0 ;
30881 int res2 = 0 ;
30882 PyObject * obj0 = 0 ;
30883 PyObject * obj1 = 0 ;
30884 char * kwnames[] = {
30885 (char *) "self",(char *) "other", NULL
30886 };
30887
30888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30890 if (!SWIG_IsOK(res1)) {
30891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30892 }
30893 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30894 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30895 if (!SWIG_IsOK(res2)) {
30896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30897 }
30898 if (!argp2) {
30899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30900 }
30901 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30902 {
30903 PyThreadState* __tstate = wxPyBeginAllowThreads();
30904 {
30905 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30906 result = (wxDateSpan *) &_result_ref;
30907 }
30908 wxPyEndAllowThreads(__tstate);
30909 if (PyErr_Occurred()) SWIG_fail;
30910 }
30911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30912 return resultobj;
30913 fail:
30914 return NULL;
30915 }
30916
30917
30918 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30919 PyObject *resultobj = 0;
30920 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30921 wxDateSpan *result = 0 ;
30922 void *argp1 = 0 ;
30923 int res1 = 0 ;
30924 PyObject *swig_obj[1] ;
30925
30926 if (!args) SWIG_fail;
30927 swig_obj[0] = args;
30928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30929 if (!SWIG_IsOK(res1)) {
30930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30931 }
30932 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 {
30936 wxDateSpan &_result_ref = (arg1)->Neg();
30937 result = (wxDateSpan *) &_result_ref;
30938 }
30939 wxPyEndAllowThreads(__tstate);
30940 if (PyErr_Occurred()) SWIG_fail;
30941 }
30942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30943 return resultobj;
30944 fail:
30945 return NULL;
30946 }
30947
30948
30949 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30950 PyObject *resultobj = 0;
30951 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30952 int arg2 ;
30953 wxDateSpan *result = 0 ;
30954 void *argp1 = 0 ;
30955 int res1 = 0 ;
30956 int val2 ;
30957 int ecode2 = 0 ;
30958 PyObject * obj0 = 0 ;
30959 PyObject * obj1 = 0 ;
30960 char * kwnames[] = {
30961 (char *) "self",(char *) "factor", NULL
30962 };
30963
30964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30966 if (!SWIG_IsOK(res1)) {
30967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30968 }
30969 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30970 ecode2 = SWIG_AsVal_int(obj1, &val2);
30971 if (!SWIG_IsOK(ecode2)) {
30972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30973 }
30974 arg2 = static_cast< int >(val2);
30975 {
30976 PyThreadState* __tstate = wxPyBeginAllowThreads();
30977 {
30978 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30979 result = (wxDateSpan *) &_result_ref;
30980 }
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30985 return resultobj;
30986 fail:
30987 return NULL;
30988 }
30989
30990
30991 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30992 PyObject *resultobj = 0;
30993 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30994 wxDateSpan *arg2 = 0 ;
30995 wxDateSpan *result = 0 ;
30996 void *argp1 = 0 ;
30997 int res1 = 0 ;
30998 void *argp2 = 0 ;
30999 int res2 = 0 ;
31000 PyObject * obj0 = 0 ;
31001 PyObject * obj1 = 0 ;
31002 char * kwnames[] = {
31003 (char *) "self",(char *) "other", NULL
31004 };
31005
31006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31008 if (!SWIG_IsOK(res1)) {
31009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31010 }
31011 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31012 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31013 if (!SWIG_IsOK(res2)) {
31014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31015 }
31016 if (!argp2) {
31017 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31018 }
31019 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31020 {
31021 PyThreadState* __tstate = wxPyBeginAllowThreads();
31022 {
31023 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31024 result = (wxDateSpan *) &_result_ref;
31025 }
31026 wxPyEndAllowThreads(__tstate);
31027 if (PyErr_Occurred()) SWIG_fail;
31028 }
31029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31030 return resultobj;
31031 fail:
31032 return NULL;
31033 }
31034
31035
31036 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31037 PyObject *resultobj = 0;
31038 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31039 wxDateSpan *arg2 = 0 ;
31040 wxDateSpan *result = 0 ;
31041 void *argp1 = 0 ;
31042 int res1 = 0 ;
31043 void *argp2 = 0 ;
31044 int res2 = 0 ;
31045 PyObject * obj0 = 0 ;
31046 PyObject * obj1 = 0 ;
31047 char * kwnames[] = {
31048 (char *) "self",(char *) "other", NULL
31049 };
31050
31051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31053 if (!SWIG_IsOK(res1)) {
31054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31055 }
31056 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31057 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31058 if (!SWIG_IsOK(res2)) {
31059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31060 }
31061 if (!argp2) {
31062 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31063 }
31064 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31065 {
31066 PyThreadState* __tstate = wxPyBeginAllowThreads();
31067 {
31068 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31069 result = (wxDateSpan *) &_result_ref;
31070 }
31071 wxPyEndAllowThreads(__tstate);
31072 if (PyErr_Occurred()) SWIG_fail;
31073 }
31074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31075 return resultobj;
31076 fail:
31077 return NULL;
31078 }
31079
31080
31081 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31082 PyObject *resultobj = 0;
31083 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31084 wxDateSpan *result = 0 ;
31085 void *argp1 = 0 ;
31086 int res1 = 0 ;
31087 PyObject *swig_obj[1] ;
31088
31089 if (!args) SWIG_fail;
31090 swig_obj[0] = args;
31091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31092 if (!SWIG_IsOK(res1)) {
31093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31094 }
31095 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31096 {
31097 PyThreadState* __tstate = wxPyBeginAllowThreads();
31098 {
31099 wxDateSpan &_result_ref = (arg1)->operator -();
31100 result = (wxDateSpan *) &_result_ref;
31101 }
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31106 return resultobj;
31107 fail:
31108 return NULL;
31109 }
31110
31111
31112 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31113 PyObject *resultobj = 0;
31114 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31115 int arg2 ;
31116 wxDateSpan *result = 0 ;
31117 void *argp1 = 0 ;
31118 int res1 = 0 ;
31119 int val2 ;
31120 int ecode2 = 0 ;
31121 PyObject * obj0 = 0 ;
31122 PyObject * obj1 = 0 ;
31123 char * kwnames[] = {
31124 (char *) "self",(char *) "factor", NULL
31125 };
31126
31127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31129 if (!SWIG_IsOK(res1)) {
31130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31131 }
31132 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31133 ecode2 = SWIG_AsVal_int(obj1, &val2);
31134 if (!SWIG_IsOK(ecode2)) {
31135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31136 }
31137 arg2 = static_cast< int >(val2);
31138 {
31139 PyThreadState* __tstate = wxPyBeginAllowThreads();
31140 {
31141 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31142 result = (wxDateSpan *) &_result_ref;
31143 }
31144 wxPyEndAllowThreads(__tstate);
31145 if (PyErr_Occurred()) SWIG_fail;
31146 }
31147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31148 return resultobj;
31149 fail:
31150 return NULL;
31151 }
31152
31153
31154 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31155 PyObject *resultobj = 0;
31156 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31157 wxDateSpan *arg2 = 0 ;
31158 wxDateSpan result;
31159 void *argp1 = 0 ;
31160 int res1 = 0 ;
31161 void *argp2 = 0 ;
31162 int res2 = 0 ;
31163 PyObject * obj0 = 0 ;
31164 PyObject * obj1 = 0 ;
31165 char * kwnames[] = {
31166 (char *) "self",(char *) "other", NULL
31167 };
31168
31169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31171 if (!SWIG_IsOK(res1)) {
31172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31173 }
31174 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31175 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31176 if (!SWIG_IsOK(res2)) {
31177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31178 }
31179 if (!argp2) {
31180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31181 }
31182 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31183 {
31184 PyThreadState* __tstate = wxPyBeginAllowThreads();
31185 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31197 PyObject *resultobj = 0;
31198 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31199 wxDateSpan *arg2 = 0 ;
31200 wxDateSpan result;
31201 void *argp1 = 0 ;
31202 int res1 = 0 ;
31203 void *argp2 = 0 ;
31204 int res2 = 0 ;
31205 PyObject * obj0 = 0 ;
31206 PyObject * obj1 = 0 ;
31207 char * kwnames[] = {
31208 (char *) "self",(char *) "other", NULL
31209 };
31210
31211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31213 if (!SWIG_IsOK(res1)) {
31214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31215 }
31216 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31217 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31218 if (!SWIG_IsOK(res2)) {
31219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31220 }
31221 if (!argp2) {
31222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31223 }
31224 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31225 {
31226 PyThreadState* __tstate = wxPyBeginAllowThreads();
31227 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31228 wxPyEndAllowThreads(__tstate);
31229 if (PyErr_Occurred()) SWIG_fail;
31230 }
31231 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31232 return resultobj;
31233 fail:
31234 return NULL;
31235 }
31236
31237
31238 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31239 PyObject *resultobj = 0;
31240 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31241 int arg2 ;
31242 wxDateSpan result;
31243 void *argp1 = 0 ;
31244 int res1 = 0 ;
31245 int val2 ;
31246 int ecode2 = 0 ;
31247 PyObject * obj0 = 0 ;
31248 PyObject * obj1 = 0 ;
31249 char * kwnames[] = {
31250 (char *) "self",(char *) "n", NULL
31251 };
31252
31253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31255 if (!SWIG_IsOK(res1)) {
31256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31257 }
31258 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31259 ecode2 = SWIG_AsVal_int(obj1, &val2);
31260 if (!SWIG_IsOK(ecode2)) {
31261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31262 }
31263 arg2 = static_cast< int >(val2);
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 result = wxDateSpan___mul__(arg1,arg2);
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31271 return resultobj;
31272 fail:
31273 return NULL;
31274 }
31275
31276
31277 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31278 PyObject *resultobj = 0;
31279 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31280 int arg2 ;
31281 wxDateSpan result;
31282 void *argp1 = 0 ;
31283 int res1 = 0 ;
31284 int val2 ;
31285 int ecode2 = 0 ;
31286 PyObject * obj0 = 0 ;
31287 PyObject * obj1 = 0 ;
31288 char * kwnames[] = {
31289 (char *) "self",(char *) "n", NULL
31290 };
31291
31292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31294 if (!SWIG_IsOK(res1)) {
31295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31296 }
31297 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31298 ecode2 = SWIG_AsVal_int(obj1, &val2);
31299 if (!SWIG_IsOK(ecode2)) {
31300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31301 }
31302 arg2 = static_cast< int >(val2);
31303 {
31304 PyThreadState* __tstate = wxPyBeginAllowThreads();
31305 result = wxDateSpan___rmul__(arg1,arg2);
31306 wxPyEndAllowThreads(__tstate);
31307 if (PyErr_Occurred()) SWIG_fail;
31308 }
31309 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31310 return resultobj;
31311 fail:
31312 return NULL;
31313 }
31314
31315
31316 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31317 PyObject *resultobj = 0;
31318 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31319 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31320 bool result;
31321 void *argp1 = 0 ;
31322 int res1 = 0 ;
31323 void *argp2 = 0 ;
31324 int res2 = 0 ;
31325 PyObject * obj0 = 0 ;
31326 PyObject * obj1 = 0 ;
31327 char * kwnames[] = {
31328 (char *) "self",(char *) "other", NULL
31329 };
31330
31331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31333 if (!SWIG_IsOK(res1)) {
31334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31335 }
31336 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31338 if (!SWIG_IsOK(res2)) {
31339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31340 }
31341 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31342 {
31343 PyThreadState* __tstate = wxPyBeginAllowThreads();
31344 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31345 wxPyEndAllowThreads(__tstate);
31346 if (PyErr_Occurred()) SWIG_fail;
31347 }
31348 {
31349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31350 }
31351 return resultobj;
31352 fail:
31353 return NULL;
31354 }
31355
31356
31357 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31358 PyObject *resultobj = 0;
31359 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31360 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31361 bool result;
31362 void *argp1 = 0 ;
31363 int res1 = 0 ;
31364 void *argp2 = 0 ;
31365 int res2 = 0 ;
31366 PyObject * obj0 = 0 ;
31367 PyObject * obj1 = 0 ;
31368 char * kwnames[] = {
31369 (char *) "self",(char *) "other", NULL
31370 };
31371
31372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31374 if (!SWIG_IsOK(res1)) {
31375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31376 }
31377 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31379 if (!SWIG_IsOK(res2)) {
31380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31381 }
31382 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 {
31390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31391 }
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31399 PyObject *obj;
31400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31401 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31402 return SWIG_Py_Void();
31403 }
31404
31405 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31406 return SWIG_Python_InitShadowInstance(args);
31407 }
31408
31409 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31410 PyObject *resultobj = 0;
31411 long result;
31412
31413 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31414 {
31415 PyThreadState* __tstate = wxPyBeginAllowThreads();
31416 result = (long)wxGetLocalTime();
31417 wxPyEndAllowThreads(__tstate);
31418 if (PyErr_Occurred()) SWIG_fail;
31419 }
31420 resultobj = SWIG_From_long(static_cast< long >(result));
31421 return resultobj;
31422 fail:
31423 return NULL;
31424 }
31425
31426
31427 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31428 PyObject *resultobj = 0;
31429 long result;
31430
31431 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31432 {
31433 PyThreadState* __tstate = wxPyBeginAllowThreads();
31434 result = (long)wxGetUTCTime();
31435 wxPyEndAllowThreads(__tstate);
31436 if (PyErr_Occurred()) SWIG_fail;
31437 }
31438 resultobj = SWIG_From_long(static_cast< long >(result));
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31446 PyObject *resultobj = 0;
31447 long result;
31448
31449 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 result = (long)wxGetCurrentTime();
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 resultobj = SWIG_From_long(static_cast< long >(result));
31457 return resultobj;
31458 fail:
31459 return NULL;
31460 }
31461
31462
31463 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31464 PyObject *resultobj = 0;
31465 wxLongLong result;
31466
31467 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31468 {
31469 PyThreadState* __tstate = wxPyBeginAllowThreads();
31470 result = wxGetLocalTimeMillis();
31471 wxPyEndAllowThreads(__tstate);
31472 if (PyErr_Occurred()) SWIG_fail;
31473 }
31474 {
31475 PyObject *hi, *lo, *shifter, *shifted;
31476 hi = PyLong_FromLong( (&result)->GetHi() );
31477 lo = PyLong_FromLong( (&result)->GetLo() );
31478 shifter = PyLong_FromLong(32);
31479 shifted = PyNumber_Lshift(hi, shifter);
31480 resultobj = PyNumber_Or(shifted, lo);
31481 Py_DECREF(hi);
31482 Py_DECREF(lo);
31483 Py_DECREF(shifter);
31484 Py_DECREF(shifted);
31485 }
31486 return resultobj;
31487 fail:
31488 return NULL;
31489 }
31490
31491
31492 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31493 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31494 return 1;
31495 }
31496
31497
31498 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31499 PyObject *pyobj = 0;
31500
31501 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31502 return pyobj;
31503 }
31504
31505
31506 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31507 PyObject *resultobj = 0;
31508 wxDataFormatId arg1 ;
31509 wxDataFormat *result = 0 ;
31510 int val1 ;
31511 int ecode1 = 0 ;
31512 PyObject * obj0 = 0 ;
31513 char * kwnames[] = {
31514 (char *) "type", NULL
31515 };
31516
31517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31518 ecode1 = SWIG_AsVal_int(obj0, &val1);
31519 if (!SWIG_IsOK(ecode1)) {
31520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31521 }
31522 arg1 = static_cast< wxDataFormatId >(val1);
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 result = (wxDataFormat *)new wxDataFormat(arg1);
31526 wxPyEndAllowThreads(__tstate);
31527 if (PyErr_Occurred()) SWIG_fail;
31528 }
31529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31530 return resultobj;
31531 fail:
31532 return NULL;
31533 }
31534
31535
31536 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31537 PyObject *resultobj = 0;
31538 wxString *arg1 = 0 ;
31539 wxDataFormat *result = 0 ;
31540 bool temp1 = false ;
31541 PyObject * obj0 = 0 ;
31542 char * kwnames[] = {
31543 (char *) "format", NULL
31544 };
31545
31546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31547 {
31548 arg1 = wxString_in_helper(obj0);
31549 if (arg1 == NULL) SWIG_fail;
31550 temp1 = true;
31551 }
31552 {
31553 PyThreadState* __tstate = wxPyBeginAllowThreads();
31554 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31555 wxPyEndAllowThreads(__tstate);
31556 if (PyErr_Occurred()) SWIG_fail;
31557 }
31558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31559 {
31560 if (temp1)
31561 delete arg1;
31562 }
31563 return resultobj;
31564 fail:
31565 {
31566 if (temp1)
31567 delete arg1;
31568 }
31569 return NULL;
31570 }
31571
31572
31573 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31574 PyObject *resultobj = 0;
31575 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31576 void *argp1 = 0 ;
31577 int res1 = 0 ;
31578 PyObject *swig_obj[1] ;
31579
31580 if (!args) SWIG_fail;
31581 swig_obj[0] = args;
31582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31583 if (!SWIG_IsOK(res1)) {
31584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31585 }
31586 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31587 {
31588 PyThreadState* __tstate = wxPyBeginAllowThreads();
31589 delete arg1;
31590
31591 wxPyEndAllowThreads(__tstate);
31592 if (PyErr_Occurred()) SWIG_fail;
31593 }
31594 resultobj = SWIG_Py_Void();
31595 return resultobj;
31596 fail:
31597 return NULL;
31598 }
31599
31600
31601 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31602 PyObject *resultobj = 0;
31603 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31604 wxDataFormatId arg2 ;
31605 bool result;
31606 void *argp1 = 0 ;
31607 int res1 = 0 ;
31608 int val2 ;
31609 int ecode2 = 0 ;
31610
31611 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31613 if (!SWIG_IsOK(res1)) {
31614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31615 }
31616 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31617 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31618 if (!SWIG_IsOK(ecode2)) {
31619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31620 }
31621 arg2 = static_cast< wxDataFormatId >(val2);
31622 {
31623 PyThreadState* __tstate = wxPyBeginAllowThreads();
31624 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31625 wxPyEndAllowThreads(__tstate);
31626 if (PyErr_Occurred()) SWIG_fail;
31627 }
31628 {
31629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31630 }
31631 return resultobj;
31632 fail:
31633 return NULL;
31634 }
31635
31636
31637 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31638 PyObject *resultobj = 0;
31639 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31640 wxDataFormatId arg2 ;
31641 bool result;
31642 void *argp1 = 0 ;
31643 int res1 = 0 ;
31644 int val2 ;
31645 int ecode2 = 0 ;
31646
31647 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31649 if (!SWIG_IsOK(res1)) {
31650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31651 }
31652 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31653 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31654 if (!SWIG_IsOK(ecode2)) {
31655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31656 }
31657 arg2 = static_cast< wxDataFormatId >(val2);
31658 {
31659 PyThreadState* __tstate = wxPyBeginAllowThreads();
31660 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31661 wxPyEndAllowThreads(__tstate);
31662 if (PyErr_Occurred()) SWIG_fail;
31663 }
31664 {
31665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31666 }
31667 return resultobj;
31668 fail:
31669 return NULL;
31670 }
31671
31672
31673 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31674 PyObject *resultobj = 0;
31675 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31676 wxDataFormat *arg2 = 0 ;
31677 bool result;
31678 void *argp1 = 0 ;
31679 int res1 = 0 ;
31680 void *argp2 = 0 ;
31681 int res2 = 0 ;
31682
31683 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31685 if (!SWIG_IsOK(res1)) {
31686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31687 }
31688 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31689 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31690 if (!SWIG_IsOK(res2)) {
31691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31692 }
31693 if (!argp2) {
31694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31695 }
31696 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31697 {
31698 PyThreadState* __tstate = wxPyBeginAllowThreads();
31699 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31700 wxPyEndAllowThreads(__tstate);
31701 if (PyErr_Occurred()) SWIG_fail;
31702 }
31703 {
31704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31705 }
31706 return resultobj;
31707 fail:
31708 return NULL;
31709 }
31710
31711
31712 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31713 int argc;
31714 PyObject *argv[3];
31715
31716 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31717 --argc;
31718 if (argc == 2) {
31719 int _v = 0;
31720 {
31721 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31722 _v = SWIG_CheckState(res);
31723 }
31724 if (!_v) goto check_1;
31725 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31726 }
31727 check_1:
31728
31729 if (argc == 2) {
31730 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31731 }
31732
31733 fail:
31734 Py_INCREF(Py_NotImplemented);
31735 return Py_NotImplemented;
31736 }
31737
31738
31739 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31740 PyObject *resultobj = 0;
31741 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31742 wxDataFormat *arg2 = 0 ;
31743 bool result;
31744 void *argp1 = 0 ;
31745 int res1 = 0 ;
31746 void *argp2 = 0 ;
31747 int res2 = 0 ;
31748
31749 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31751 if (!SWIG_IsOK(res1)) {
31752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31753 }
31754 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31755 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31756 if (!SWIG_IsOK(res2)) {
31757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31758 }
31759 if (!argp2) {
31760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31761 }
31762 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31763 {
31764 PyThreadState* __tstate = wxPyBeginAllowThreads();
31765 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 {
31770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31771 }
31772 return resultobj;
31773 fail:
31774 return NULL;
31775 }
31776
31777
31778 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31779 int argc;
31780 PyObject *argv[3];
31781
31782 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31783 --argc;
31784 if (argc == 2) {
31785 int _v = 0;
31786 {
31787 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31788 _v = SWIG_CheckState(res);
31789 }
31790 if (!_v) goto check_1;
31791 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31792 }
31793 check_1:
31794
31795 if (argc == 2) {
31796 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31797 }
31798
31799 fail:
31800 Py_INCREF(Py_NotImplemented);
31801 return Py_NotImplemented;
31802 }
31803
31804
31805 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31806 PyObject *resultobj = 0;
31807 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31808 wxDataFormatId arg2 ;
31809 void *argp1 = 0 ;
31810 int res1 = 0 ;
31811 int val2 ;
31812 int ecode2 = 0 ;
31813 PyObject * obj0 = 0 ;
31814 PyObject * obj1 = 0 ;
31815 char * kwnames[] = {
31816 (char *) "self",(char *) "format", NULL
31817 };
31818
31819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31821 if (!SWIG_IsOK(res1)) {
31822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31823 }
31824 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31825 ecode2 = SWIG_AsVal_int(obj1, &val2);
31826 if (!SWIG_IsOK(ecode2)) {
31827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31828 }
31829 arg2 = static_cast< wxDataFormatId >(val2);
31830 {
31831 PyThreadState* __tstate = wxPyBeginAllowThreads();
31832 (arg1)->SetType(arg2);
31833 wxPyEndAllowThreads(__tstate);
31834 if (PyErr_Occurred()) SWIG_fail;
31835 }
31836 resultobj = SWIG_Py_Void();
31837 return resultobj;
31838 fail:
31839 return NULL;
31840 }
31841
31842
31843 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31844 PyObject *resultobj = 0;
31845 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31846 wxDataFormatId result;
31847 void *argp1 = 0 ;
31848 int res1 = 0 ;
31849 PyObject *swig_obj[1] ;
31850
31851 if (!args) SWIG_fail;
31852 swig_obj[0] = args;
31853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31854 if (!SWIG_IsOK(res1)) {
31855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31856 }
31857 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31858 {
31859 PyThreadState* __tstate = wxPyBeginAllowThreads();
31860 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31861 wxPyEndAllowThreads(__tstate);
31862 if (PyErr_Occurred()) SWIG_fail;
31863 }
31864 resultobj = SWIG_From_int(static_cast< int >(result));
31865 return resultobj;
31866 fail:
31867 return NULL;
31868 }
31869
31870
31871 SWIGINTERN PyObject *_wrap_DataFormat__GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31872 PyObject *resultobj = 0;
31873 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31874 wxString result;
31875 void *argp1 = 0 ;
31876 int res1 = 0 ;
31877 PyObject *swig_obj[1] ;
31878
31879 if (!args) SWIG_fail;
31880 swig_obj[0] = args;
31881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31882 if (!SWIG_IsOK(res1)) {
31883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat__GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31884 }
31885 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31886 {
31887 PyThreadState* __tstate = wxPyBeginAllowThreads();
31888 result = ((wxDataFormat const *)arg1)->GetId();
31889 wxPyEndAllowThreads(__tstate);
31890 if (PyErr_Occurred()) SWIG_fail;
31891 }
31892 {
31893 #if wxUSE_UNICODE
31894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31895 #else
31896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31897 #endif
31898 }
31899 return resultobj;
31900 fail:
31901 return NULL;
31902 }
31903
31904
31905 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31906 PyObject *resultobj = 0;
31907 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31908 wxString *arg2 = 0 ;
31909 void *argp1 = 0 ;
31910 int res1 = 0 ;
31911 bool temp2 = false ;
31912 PyObject * obj0 = 0 ;
31913 PyObject * obj1 = 0 ;
31914 char * kwnames[] = {
31915 (char *) "self",(char *) "format", NULL
31916 };
31917
31918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31920 if (!SWIG_IsOK(res1)) {
31921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31922 }
31923 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31924 {
31925 arg2 = wxString_in_helper(obj1);
31926 if (arg2 == NULL) SWIG_fail;
31927 temp2 = true;
31928 }
31929 {
31930 PyThreadState* __tstate = wxPyBeginAllowThreads();
31931 (arg1)->SetId((wxString const &)*arg2);
31932 wxPyEndAllowThreads(__tstate);
31933 if (PyErr_Occurred()) SWIG_fail;
31934 }
31935 resultobj = SWIG_Py_Void();
31936 {
31937 if (temp2)
31938 delete arg2;
31939 }
31940 return resultobj;
31941 fail:
31942 {
31943 if (temp2)
31944 delete arg2;
31945 }
31946 return NULL;
31947 }
31948
31949
31950 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31951 PyObject *obj;
31952 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31953 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31954 return SWIG_Py_Void();
31955 }
31956
31957 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31958 return SWIG_Python_InitShadowInstance(args);
31959 }
31960
31961 SWIGINTERN int FormatInvalid_set(PyObject *) {
31962 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31963 return 1;
31964 }
31965
31966
31967 SWIGINTERN PyObject *FormatInvalid_get(void) {
31968 PyObject *pyobj = 0;
31969
31970 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31971 return pyobj;
31972 }
31973
31974
31975 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31976 PyObject *resultobj = 0;
31977 wxDataObject *arg1 = (wxDataObject *) 0 ;
31978 void *argp1 = 0 ;
31979 int res1 = 0 ;
31980 PyObject *swig_obj[1] ;
31981
31982 if (!args) SWIG_fail;
31983 swig_obj[0] = args;
31984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31985 if (!SWIG_IsOK(res1)) {
31986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31987 }
31988 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31989 {
31990 PyThreadState* __tstate = wxPyBeginAllowThreads();
31991 delete arg1;
31992
31993 wxPyEndAllowThreads(__tstate);
31994 if (PyErr_Occurred()) SWIG_fail;
31995 }
31996 resultobj = SWIG_Py_Void();
31997 return resultobj;
31998 fail:
31999 return NULL;
32000 }
32001
32002
32003 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32004 PyObject *resultobj = 0;
32005 wxDataObject *arg1 = (wxDataObject *) 0 ;
32006 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32007 SwigValueWrapper<wxDataFormat > result;
32008 void *argp1 = 0 ;
32009 int res1 = 0 ;
32010 int val2 ;
32011 int ecode2 = 0 ;
32012 PyObject * obj0 = 0 ;
32013 PyObject * obj1 = 0 ;
32014 char * kwnames[] = {
32015 (char *) "self",(char *) "dir", NULL
32016 };
32017
32018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32020 if (!SWIG_IsOK(res1)) {
32021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32022 }
32023 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32024 if (obj1) {
32025 ecode2 = SWIG_AsVal_int(obj1, &val2);
32026 if (!SWIG_IsOK(ecode2)) {
32027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32028 }
32029 arg2 = static_cast< wxDataObject::Direction >(val2);
32030 }
32031 {
32032 PyThreadState* __tstate = wxPyBeginAllowThreads();
32033 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32034 wxPyEndAllowThreads(__tstate);
32035 if (PyErr_Occurred()) SWIG_fail;
32036 }
32037 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32038 return resultobj;
32039 fail:
32040 return NULL;
32041 }
32042
32043
32044 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32045 PyObject *resultobj = 0;
32046 wxDataObject *arg1 = (wxDataObject *) 0 ;
32047 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32048 size_t result;
32049 void *argp1 = 0 ;
32050 int res1 = 0 ;
32051 int val2 ;
32052 int ecode2 = 0 ;
32053 PyObject * obj0 = 0 ;
32054 PyObject * obj1 = 0 ;
32055 char * kwnames[] = {
32056 (char *) "self",(char *) "dir", NULL
32057 };
32058
32059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32061 if (!SWIG_IsOK(res1)) {
32062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32063 }
32064 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32065 if (obj1) {
32066 ecode2 = SWIG_AsVal_int(obj1, &val2);
32067 if (!SWIG_IsOK(ecode2)) {
32068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32069 }
32070 arg2 = static_cast< wxDataObject::Direction >(val2);
32071 }
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32079 return resultobj;
32080 fail:
32081 return NULL;
32082 }
32083
32084
32085 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32086 PyObject *resultobj = 0;
32087 wxDataObject *arg1 = (wxDataObject *) 0 ;
32088 wxDataFormat *arg2 = 0 ;
32089 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32090 bool result;
32091 void *argp1 = 0 ;
32092 int res1 = 0 ;
32093 void *argp2 = 0 ;
32094 int res2 = 0 ;
32095 int val3 ;
32096 int ecode3 = 0 ;
32097 PyObject * obj0 = 0 ;
32098 PyObject * obj1 = 0 ;
32099 PyObject * obj2 = 0 ;
32100 char * kwnames[] = {
32101 (char *) "self",(char *) "format",(char *) "dir", NULL
32102 };
32103
32104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32106 if (!SWIG_IsOK(res1)) {
32107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32108 }
32109 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32110 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32111 if (!SWIG_IsOK(res2)) {
32112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32113 }
32114 if (!argp2) {
32115 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32116 }
32117 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32118 if (obj2) {
32119 ecode3 = SWIG_AsVal_int(obj2, &val3);
32120 if (!SWIG_IsOK(ecode3)) {
32121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32122 }
32123 arg3 = static_cast< wxDataObject::Direction >(val3);
32124 }
32125 {
32126 PyThreadState* __tstate = wxPyBeginAllowThreads();
32127 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32128 wxPyEndAllowThreads(__tstate);
32129 if (PyErr_Occurred()) SWIG_fail;
32130 }
32131 {
32132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32133 }
32134 return resultobj;
32135 fail:
32136 return NULL;
32137 }
32138
32139
32140 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32141 PyObject *resultobj = 0;
32142 wxDataObject *arg1 = (wxDataObject *) 0 ;
32143 wxDataFormat *arg2 = 0 ;
32144 size_t result;
32145 void *argp1 = 0 ;
32146 int res1 = 0 ;
32147 void *argp2 = 0 ;
32148 int res2 = 0 ;
32149 PyObject * obj0 = 0 ;
32150 PyObject * obj1 = 0 ;
32151 char * kwnames[] = {
32152 (char *) "self",(char *) "format", NULL
32153 };
32154
32155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32157 if (!SWIG_IsOK(res1)) {
32158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32159 }
32160 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32161 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32162 if (!SWIG_IsOK(res2)) {
32163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32164 }
32165 if (!argp2) {
32166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32167 }
32168 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32169 {
32170 PyThreadState* __tstate = wxPyBeginAllowThreads();
32171 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32172 wxPyEndAllowThreads(__tstate);
32173 if (PyErr_Occurred()) SWIG_fail;
32174 }
32175 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32176 return resultobj;
32177 fail:
32178 return NULL;
32179 }
32180
32181
32182 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32183 PyObject *resultobj = 0;
32184 wxDataObject *arg1 = (wxDataObject *) 0 ;
32185 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32186 PyObject *result = 0 ;
32187 void *argp1 = 0 ;
32188 int res1 = 0 ;
32189 int val2 ;
32190 int ecode2 = 0 ;
32191 PyObject * obj0 = 0 ;
32192 PyObject * obj1 = 0 ;
32193 char * kwnames[] = {
32194 (char *) "self",(char *) "dir", NULL
32195 };
32196
32197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32199 if (!SWIG_IsOK(res1)) {
32200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32201 }
32202 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32203 if (obj1) {
32204 ecode2 = SWIG_AsVal_int(obj1, &val2);
32205 if (!SWIG_IsOK(ecode2)) {
32206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32207 }
32208 arg2 = static_cast< wxDataObject::Direction >(val2);
32209 }
32210 {
32211 PyThreadState* __tstate = wxPyBeginAllowThreads();
32212 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32213 wxPyEndAllowThreads(__tstate);
32214 if (PyErr_Occurred()) SWIG_fail;
32215 }
32216 resultobj = result;
32217 return resultobj;
32218 fail:
32219 return NULL;
32220 }
32221
32222
32223 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32224 PyObject *resultobj = 0;
32225 wxDataObject *arg1 = (wxDataObject *) 0 ;
32226 wxDataFormat *arg2 = 0 ;
32227 PyObject *result = 0 ;
32228 void *argp1 = 0 ;
32229 int res1 = 0 ;
32230 void *argp2 = 0 ;
32231 int res2 = 0 ;
32232 PyObject * obj0 = 0 ;
32233 PyObject * obj1 = 0 ;
32234 char * kwnames[] = {
32235 (char *) "self",(char *) "format", NULL
32236 };
32237
32238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32240 if (!SWIG_IsOK(res1)) {
32241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32242 }
32243 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32245 if (!SWIG_IsOK(res2)) {
32246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32247 }
32248 if (!argp2) {
32249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32250 }
32251 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32252 {
32253 PyThreadState* __tstate = wxPyBeginAllowThreads();
32254 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32255 wxPyEndAllowThreads(__tstate);
32256 if (PyErr_Occurred()) SWIG_fail;
32257 }
32258 resultobj = result;
32259 return resultobj;
32260 fail:
32261 return NULL;
32262 }
32263
32264
32265 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32266 PyObject *resultobj = 0;
32267 wxDataObject *arg1 = (wxDataObject *) 0 ;
32268 wxDataFormat *arg2 = 0 ;
32269 PyObject *arg3 = (PyObject *) 0 ;
32270 bool result;
32271 void *argp1 = 0 ;
32272 int res1 = 0 ;
32273 void *argp2 = 0 ;
32274 int res2 = 0 ;
32275 PyObject * obj0 = 0 ;
32276 PyObject * obj1 = 0 ;
32277 PyObject * obj2 = 0 ;
32278 char * kwnames[] = {
32279 (char *) "self",(char *) "format",(char *) "data", NULL
32280 };
32281
32282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32284 if (!SWIG_IsOK(res1)) {
32285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32286 }
32287 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32288 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32289 if (!SWIG_IsOK(res2)) {
32290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32291 }
32292 if (!argp2) {
32293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32294 }
32295 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32296 arg3 = obj2;
32297 {
32298 PyThreadState* __tstate = wxPyBeginAllowThreads();
32299 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32300 wxPyEndAllowThreads(__tstate);
32301 if (PyErr_Occurred()) SWIG_fail;
32302 }
32303 {
32304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32305 }
32306 return resultobj;
32307 fail:
32308 return NULL;
32309 }
32310
32311
32312 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32313 PyObject *obj;
32314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32315 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32316 return SWIG_Py_Void();
32317 }
32318
32319 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32320 PyObject *resultobj = 0;
32321 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32322 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32323 wxDataObjectSimple *result = 0 ;
32324 void *argp1 = 0 ;
32325 int res1 = 0 ;
32326 PyObject * obj0 = 0 ;
32327 char * kwnames[] = {
32328 (char *) "format", NULL
32329 };
32330
32331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32332 if (obj0) {
32333 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32334 if (!SWIG_IsOK(res1)) {
32335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32336 }
32337 if (!argp1) {
32338 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32339 }
32340 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32341 }
32342 {
32343 PyThreadState* __tstate = wxPyBeginAllowThreads();
32344 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32345 wxPyEndAllowThreads(__tstate);
32346 if (PyErr_Occurred()) SWIG_fail;
32347 }
32348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32349 return resultobj;
32350 fail:
32351 return NULL;
32352 }
32353
32354
32355 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32356 PyObject *resultobj = 0;
32357 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32358 wxDataFormat *result = 0 ;
32359 void *argp1 = 0 ;
32360 int res1 = 0 ;
32361 PyObject *swig_obj[1] ;
32362
32363 if (!args) SWIG_fail;
32364 swig_obj[0] = args;
32365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32366 if (!SWIG_IsOK(res1)) {
32367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32368 }
32369 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32370 {
32371 PyThreadState* __tstate = wxPyBeginAllowThreads();
32372 {
32373 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32374 result = (wxDataFormat *) &_result_ref;
32375 }
32376 wxPyEndAllowThreads(__tstate);
32377 if (PyErr_Occurred()) SWIG_fail;
32378 }
32379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32380 return resultobj;
32381 fail:
32382 return NULL;
32383 }
32384
32385
32386 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32387 PyObject *resultobj = 0;
32388 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32389 wxDataFormat *arg2 = 0 ;
32390 void *argp1 = 0 ;
32391 int res1 = 0 ;
32392 void *argp2 = 0 ;
32393 int res2 = 0 ;
32394 PyObject * obj0 = 0 ;
32395 PyObject * obj1 = 0 ;
32396 char * kwnames[] = {
32397 (char *) "self",(char *) "format", NULL
32398 };
32399
32400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32402 if (!SWIG_IsOK(res1)) {
32403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32404 }
32405 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32406 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32407 if (!SWIG_IsOK(res2)) {
32408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32409 }
32410 if (!argp2) {
32411 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32412 }
32413 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32414 {
32415 PyThreadState* __tstate = wxPyBeginAllowThreads();
32416 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32417 wxPyEndAllowThreads(__tstate);
32418 if (PyErr_Occurred()) SWIG_fail;
32419 }
32420 resultobj = SWIG_Py_Void();
32421 return resultobj;
32422 fail:
32423 return NULL;
32424 }
32425
32426
32427 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32428 PyObject *resultobj = 0;
32429 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32430 size_t result;
32431 void *argp1 = 0 ;
32432 int res1 = 0 ;
32433 PyObject *swig_obj[1] ;
32434
32435 if (!args) SWIG_fail;
32436 swig_obj[0] = args;
32437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32438 if (!SWIG_IsOK(res1)) {
32439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32440 }
32441 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32445 wxPyEndAllowThreads(__tstate);
32446 if (PyErr_Occurred()) SWIG_fail;
32447 }
32448 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32456 PyObject *resultobj = 0;
32457 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32458 PyObject *result = 0 ;
32459 void *argp1 = 0 ;
32460 int res1 = 0 ;
32461 PyObject *swig_obj[1] ;
32462
32463 if (!args) SWIG_fail;
32464 swig_obj[0] = args;
32465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32466 if (!SWIG_IsOK(res1)) {
32467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32468 }
32469 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32470 {
32471 PyThreadState* __tstate = wxPyBeginAllowThreads();
32472 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 resultobj = result;
32477 return resultobj;
32478 fail:
32479 return NULL;
32480 }
32481
32482
32483 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32484 PyObject *resultobj = 0;
32485 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32486 PyObject *arg2 = (PyObject *) 0 ;
32487 bool result;
32488 void *argp1 = 0 ;
32489 int res1 = 0 ;
32490 PyObject * obj0 = 0 ;
32491 PyObject * obj1 = 0 ;
32492 char * kwnames[] = {
32493 (char *) "self",(char *) "data", NULL
32494 };
32495
32496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32498 if (!SWIG_IsOK(res1)) {
32499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32500 }
32501 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32502 arg2 = obj1;
32503 {
32504 PyThreadState* __tstate = wxPyBeginAllowThreads();
32505 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32506 wxPyEndAllowThreads(__tstate);
32507 if (PyErr_Occurred()) SWIG_fail;
32508 }
32509 {
32510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32511 }
32512 return resultobj;
32513 fail:
32514 return NULL;
32515 }
32516
32517
32518 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32519 PyObject *obj;
32520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32521 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32522 return SWIG_Py_Void();
32523 }
32524
32525 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32526 return SWIG_Python_InitShadowInstance(args);
32527 }
32528
32529 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32530 PyObject *resultobj = 0;
32531 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32532 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32533 wxPyDataObjectSimple *result = 0 ;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 PyObject * obj0 = 0 ;
32537 char * kwnames[] = {
32538 (char *) "format", NULL
32539 };
32540
32541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32542 if (obj0) {
32543 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32544 if (!SWIG_IsOK(res1)) {
32545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32546 }
32547 if (!argp1) {
32548 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32549 }
32550 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32551 }
32552 {
32553 PyThreadState* __tstate = wxPyBeginAllowThreads();
32554 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32555 wxPyEndAllowThreads(__tstate);
32556 if (PyErr_Occurred()) SWIG_fail;
32557 }
32558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32559 return resultobj;
32560 fail:
32561 return NULL;
32562 }
32563
32564
32565 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32566 PyObject *resultobj = 0;
32567 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32568 PyObject *arg2 = (PyObject *) 0 ;
32569 PyObject *arg3 = (PyObject *) 0 ;
32570 void *argp1 = 0 ;
32571 int res1 = 0 ;
32572 PyObject * obj0 = 0 ;
32573 PyObject * obj1 = 0 ;
32574 PyObject * obj2 = 0 ;
32575 char * kwnames[] = {
32576 (char *) "self",(char *) "self",(char *) "_class", NULL
32577 };
32578
32579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32581 if (!SWIG_IsOK(res1)) {
32582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32583 }
32584 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32585 arg2 = obj1;
32586 arg3 = obj2;
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 (arg1)->_setCallbackInfo(arg2,arg3);
32590 wxPyEndAllowThreads(__tstate);
32591 if (PyErr_Occurred()) SWIG_fail;
32592 }
32593 resultobj = SWIG_Py_Void();
32594 return resultobj;
32595 fail:
32596 return NULL;
32597 }
32598
32599
32600 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32601 PyObject *obj;
32602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32603 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32604 return SWIG_Py_Void();
32605 }
32606
32607 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32608 return SWIG_Python_InitShadowInstance(args);
32609 }
32610
32611 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32612 PyObject *resultobj = 0;
32613 wxDataObjectComposite *result = 0 ;
32614
32615 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32616 {
32617 PyThreadState* __tstate = wxPyBeginAllowThreads();
32618 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32619 wxPyEndAllowThreads(__tstate);
32620 if (PyErr_Occurred()) SWIG_fail;
32621 }
32622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32623 return resultobj;
32624 fail:
32625 return NULL;
32626 }
32627
32628
32629 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32630 PyObject *resultobj = 0;
32631 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32632 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32633 bool arg3 = (bool) false ;
32634 void *argp1 = 0 ;
32635 int res1 = 0 ;
32636 int res2 = 0 ;
32637 bool val3 ;
32638 int ecode3 = 0 ;
32639 PyObject * obj0 = 0 ;
32640 PyObject * obj1 = 0 ;
32641 PyObject * obj2 = 0 ;
32642 char * kwnames[] = {
32643 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32644 };
32645
32646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32648 if (!SWIG_IsOK(res1)) {
32649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32650 }
32651 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32652 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32653 if (!SWIG_IsOK(res2)) {
32654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32655 }
32656 if (obj2) {
32657 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32658 if (!SWIG_IsOK(ecode3)) {
32659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32660 }
32661 arg3 = static_cast< bool >(val3);
32662 }
32663 {
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 (arg1)->Add(arg2,arg3);
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 resultobj = SWIG_Py_Void();
32670 return resultobj;
32671 fail:
32672 return NULL;
32673 }
32674
32675
32676 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677 PyObject *resultobj = 0;
32678 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32679 SwigValueWrapper<wxDataFormat > result;
32680 void *argp1 = 0 ;
32681 int res1 = 0 ;
32682 PyObject *swig_obj[1] ;
32683
32684 if (!args) SWIG_fail;
32685 swig_obj[0] = args;
32686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32687 if (!SWIG_IsOK(res1)) {
32688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32689 }
32690 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32691 {
32692 PyThreadState* __tstate = wxPyBeginAllowThreads();
32693 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32694 wxPyEndAllowThreads(__tstate);
32695 if (PyErr_Occurred()) SWIG_fail;
32696 }
32697 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32698 return resultobj;
32699 fail:
32700 return NULL;
32701 }
32702
32703
32704 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32705 PyObject *obj;
32706 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32707 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32708 return SWIG_Py_Void();
32709 }
32710
32711 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32712 return SWIG_Python_InitShadowInstance(args);
32713 }
32714
32715 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32716 PyObject *resultobj = 0;
32717 wxString const &arg1_defvalue = wxPyEmptyString ;
32718 wxString *arg1 = (wxString *) &arg1_defvalue ;
32719 wxTextDataObject *result = 0 ;
32720 bool temp1 = false ;
32721 PyObject * obj0 = 0 ;
32722 char * kwnames[] = {
32723 (char *) "text", NULL
32724 };
32725
32726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32727 if (obj0) {
32728 {
32729 arg1 = wxString_in_helper(obj0);
32730 if (arg1 == NULL) SWIG_fail;
32731 temp1 = true;
32732 }
32733 }
32734 {
32735 PyThreadState* __tstate = wxPyBeginAllowThreads();
32736 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32737 wxPyEndAllowThreads(__tstate);
32738 if (PyErr_Occurred()) SWIG_fail;
32739 }
32740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32741 {
32742 if (temp1)
32743 delete arg1;
32744 }
32745 return resultobj;
32746 fail:
32747 {
32748 if (temp1)
32749 delete arg1;
32750 }
32751 return NULL;
32752 }
32753
32754
32755 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32756 PyObject *resultobj = 0;
32757 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32758 size_t result;
32759 void *argp1 = 0 ;
32760 int res1 = 0 ;
32761 PyObject *swig_obj[1] ;
32762
32763 if (!args) SWIG_fail;
32764 swig_obj[0] = args;
32765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32766 if (!SWIG_IsOK(res1)) {
32767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32768 }
32769 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32770 {
32771 PyThreadState* __tstate = wxPyBeginAllowThreads();
32772 result = (size_t)(arg1)->GetTextLength();
32773 wxPyEndAllowThreads(__tstate);
32774 if (PyErr_Occurred()) SWIG_fail;
32775 }
32776 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32777 return resultobj;
32778 fail:
32779 return NULL;
32780 }
32781
32782
32783 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32784 PyObject *resultobj = 0;
32785 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32786 wxString result;
32787 void *argp1 = 0 ;
32788 int res1 = 0 ;
32789 PyObject *swig_obj[1] ;
32790
32791 if (!args) SWIG_fail;
32792 swig_obj[0] = args;
32793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32794 if (!SWIG_IsOK(res1)) {
32795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32796 }
32797 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32798 {
32799 PyThreadState* __tstate = wxPyBeginAllowThreads();
32800 result = (arg1)->GetText();
32801 wxPyEndAllowThreads(__tstate);
32802 if (PyErr_Occurred()) SWIG_fail;
32803 }
32804 {
32805 #if wxUSE_UNICODE
32806 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32807 #else
32808 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32809 #endif
32810 }
32811 return resultobj;
32812 fail:
32813 return NULL;
32814 }
32815
32816
32817 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32818 PyObject *resultobj = 0;
32819 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32820 wxString *arg2 = 0 ;
32821 void *argp1 = 0 ;
32822 int res1 = 0 ;
32823 bool temp2 = false ;
32824 PyObject * obj0 = 0 ;
32825 PyObject * obj1 = 0 ;
32826 char * kwnames[] = {
32827 (char *) "self",(char *) "text", NULL
32828 };
32829
32830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32832 if (!SWIG_IsOK(res1)) {
32833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32834 }
32835 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32836 {
32837 arg2 = wxString_in_helper(obj1);
32838 if (arg2 == NULL) SWIG_fail;
32839 temp2 = true;
32840 }
32841 {
32842 PyThreadState* __tstate = wxPyBeginAllowThreads();
32843 (arg1)->SetText((wxString const &)*arg2);
32844 wxPyEndAllowThreads(__tstate);
32845 if (PyErr_Occurred()) SWIG_fail;
32846 }
32847 resultobj = SWIG_Py_Void();
32848 {
32849 if (temp2)
32850 delete arg2;
32851 }
32852 return resultobj;
32853 fail:
32854 {
32855 if (temp2)
32856 delete arg2;
32857 }
32858 return NULL;
32859 }
32860
32861
32862 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32863 PyObject *obj;
32864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32865 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32866 return SWIG_Py_Void();
32867 }
32868
32869 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32870 return SWIG_Python_InitShadowInstance(args);
32871 }
32872
32873 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32874 PyObject *resultobj = 0;
32875 wxString const &arg1_defvalue = wxPyEmptyString ;
32876 wxString *arg1 = (wxString *) &arg1_defvalue ;
32877 wxPyTextDataObject *result = 0 ;
32878 bool temp1 = false ;
32879 PyObject * obj0 = 0 ;
32880 char * kwnames[] = {
32881 (char *) "text", NULL
32882 };
32883
32884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32885 if (obj0) {
32886 {
32887 arg1 = wxString_in_helper(obj0);
32888 if (arg1 == NULL) SWIG_fail;
32889 temp1 = true;
32890 }
32891 }
32892 {
32893 PyThreadState* __tstate = wxPyBeginAllowThreads();
32894 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32895 wxPyEndAllowThreads(__tstate);
32896 if (PyErr_Occurred()) SWIG_fail;
32897 }
32898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32899 {
32900 if (temp1)
32901 delete arg1;
32902 }
32903 return resultobj;
32904 fail:
32905 {
32906 if (temp1)
32907 delete arg1;
32908 }
32909 return NULL;
32910 }
32911
32912
32913 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32914 PyObject *resultobj = 0;
32915 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32916 PyObject *arg2 = (PyObject *) 0 ;
32917 PyObject *arg3 = (PyObject *) 0 ;
32918 void *argp1 = 0 ;
32919 int res1 = 0 ;
32920 PyObject * obj0 = 0 ;
32921 PyObject * obj1 = 0 ;
32922 PyObject * obj2 = 0 ;
32923 char * kwnames[] = {
32924 (char *) "self",(char *) "self",(char *) "_class", NULL
32925 };
32926
32927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32929 if (!SWIG_IsOK(res1)) {
32930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32931 }
32932 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32933 arg2 = obj1;
32934 arg3 = obj2;
32935 {
32936 PyThreadState* __tstate = wxPyBeginAllowThreads();
32937 (arg1)->_setCallbackInfo(arg2,arg3);
32938 wxPyEndAllowThreads(__tstate);
32939 if (PyErr_Occurred()) SWIG_fail;
32940 }
32941 resultobj = SWIG_Py_Void();
32942 return resultobj;
32943 fail:
32944 return NULL;
32945 }
32946
32947
32948 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32949 PyObject *obj;
32950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32951 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32952 return SWIG_Py_Void();
32953 }
32954
32955 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32956 return SWIG_Python_InitShadowInstance(args);
32957 }
32958
32959 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32960 PyObject *resultobj = 0;
32961 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32962 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32963 wxBitmapDataObject *result = 0 ;
32964 void *argp1 = 0 ;
32965 int res1 = 0 ;
32966 PyObject * obj0 = 0 ;
32967 char * kwnames[] = {
32968 (char *) "bitmap", NULL
32969 };
32970
32971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32972 if (obj0) {
32973 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32974 if (!SWIG_IsOK(res1)) {
32975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32976 }
32977 if (!argp1) {
32978 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32979 }
32980 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32981 }
32982 {
32983 PyThreadState* __tstate = wxPyBeginAllowThreads();
32984 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32985 wxPyEndAllowThreads(__tstate);
32986 if (PyErr_Occurred()) SWIG_fail;
32987 }
32988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32989 return resultobj;
32990 fail:
32991 return NULL;
32992 }
32993
32994
32995 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32996 PyObject *resultobj = 0;
32997 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32998 wxBitmap result;
32999 void *argp1 = 0 ;
33000 int res1 = 0 ;
33001 PyObject *swig_obj[1] ;
33002
33003 if (!args) SWIG_fail;
33004 swig_obj[0] = args;
33005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33006 if (!SWIG_IsOK(res1)) {
33007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33008 }
33009 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33010 {
33011 PyThreadState* __tstate = wxPyBeginAllowThreads();
33012 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33013 wxPyEndAllowThreads(__tstate);
33014 if (PyErr_Occurred()) SWIG_fail;
33015 }
33016 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33017 return resultobj;
33018 fail:
33019 return NULL;
33020 }
33021
33022
33023 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33024 PyObject *resultobj = 0;
33025 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33026 wxBitmap *arg2 = 0 ;
33027 void *argp1 = 0 ;
33028 int res1 = 0 ;
33029 void *argp2 = 0 ;
33030 int res2 = 0 ;
33031 PyObject * obj0 = 0 ;
33032 PyObject * obj1 = 0 ;
33033 char * kwnames[] = {
33034 (char *) "self",(char *) "bitmap", NULL
33035 };
33036
33037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33039 if (!SWIG_IsOK(res1)) {
33040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33041 }
33042 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33043 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33044 if (!SWIG_IsOK(res2)) {
33045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33046 }
33047 if (!argp2) {
33048 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33049 }
33050 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33051 {
33052 PyThreadState* __tstate = wxPyBeginAllowThreads();
33053 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33054 wxPyEndAllowThreads(__tstate);
33055 if (PyErr_Occurred()) SWIG_fail;
33056 }
33057 resultobj = SWIG_Py_Void();
33058 return resultobj;
33059 fail:
33060 return NULL;
33061 }
33062
33063
33064 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33065 PyObject *obj;
33066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33067 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33068 return SWIG_Py_Void();
33069 }
33070
33071 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33072 return SWIG_Python_InitShadowInstance(args);
33073 }
33074
33075 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33076 PyObject *resultobj = 0;
33077 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33078 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33079 wxPyBitmapDataObject *result = 0 ;
33080 void *argp1 = 0 ;
33081 int res1 = 0 ;
33082 PyObject * obj0 = 0 ;
33083 char * kwnames[] = {
33084 (char *) "bitmap", NULL
33085 };
33086
33087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33088 if (obj0) {
33089 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33090 if (!SWIG_IsOK(res1)) {
33091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33092 }
33093 if (!argp1) {
33094 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33095 }
33096 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33097 }
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33112 PyObject *resultobj = 0;
33113 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33114 PyObject *arg2 = (PyObject *) 0 ;
33115 PyObject *arg3 = (PyObject *) 0 ;
33116 void *argp1 = 0 ;
33117 int res1 = 0 ;
33118 PyObject * obj0 = 0 ;
33119 PyObject * obj1 = 0 ;
33120 PyObject * obj2 = 0 ;
33121 char * kwnames[] = {
33122 (char *) "self",(char *) "self",(char *) "_class", NULL
33123 };
33124
33125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33127 if (!SWIG_IsOK(res1)) {
33128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33129 }
33130 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33131 arg2 = obj1;
33132 arg3 = obj2;
33133 {
33134 PyThreadState* __tstate = wxPyBeginAllowThreads();
33135 (arg1)->_setCallbackInfo(arg2,arg3);
33136 wxPyEndAllowThreads(__tstate);
33137 if (PyErr_Occurred()) SWIG_fail;
33138 }
33139 resultobj = SWIG_Py_Void();
33140 return resultobj;
33141 fail:
33142 return NULL;
33143 }
33144
33145
33146 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33147 PyObject *obj;
33148 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33149 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33150 return SWIG_Py_Void();
33151 }
33152
33153 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33154 return SWIG_Python_InitShadowInstance(args);
33155 }
33156
33157 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33158 PyObject *resultobj = 0;
33159 wxFileDataObject *result = 0 ;
33160
33161 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33162 {
33163 PyThreadState* __tstate = wxPyBeginAllowThreads();
33164 result = (wxFileDataObject *)new wxFileDataObject();
33165 wxPyEndAllowThreads(__tstate);
33166 if (PyErr_Occurred()) SWIG_fail;
33167 }
33168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33169 return resultobj;
33170 fail:
33171 return NULL;
33172 }
33173
33174
33175 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33176 PyObject *resultobj = 0;
33177 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33178 wxArrayString *result = 0 ;
33179 void *argp1 = 0 ;
33180 int res1 = 0 ;
33181 PyObject *swig_obj[1] ;
33182
33183 if (!args) SWIG_fail;
33184 swig_obj[0] = args;
33185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33186 if (!SWIG_IsOK(res1)) {
33187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33188 }
33189 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33190 {
33191 PyThreadState* __tstate = wxPyBeginAllowThreads();
33192 {
33193 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33194 result = (wxArrayString *) &_result_ref;
33195 }
33196 wxPyEndAllowThreads(__tstate);
33197 if (PyErr_Occurred()) SWIG_fail;
33198 }
33199 {
33200 resultobj = wxArrayString2PyList_helper(*result);
33201 }
33202 return resultobj;
33203 fail:
33204 return NULL;
33205 }
33206
33207
33208 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33209 PyObject *resultobj = 0;
33210 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33211 wxString *arg2 = 0 ;
33212 void *argp1 = 0 ;
33213 int res1 = 0 ;
33214 bool temp2 = false ;
33215 PyObject * obj0 = 0 ;
33216 PyObject * obj1 = 0 ;
33217 char * kwnames[] = {
33218 (char *) "self",(char *) "filename", NULL
33219 };
33220
33221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33223 if (!SWIG_IsOK(res1)) {
33224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33225 }
33226 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33227 {
33228 arg2 = wxString_in_helper(obj1);
33229 if (arg2 == NULL) SWIG_fail;
33230 temp2 = true;
33231 }
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 (arg1)->AddFile((wxString const &)*arg2);
33235 wxPyEndAllowThreads(__tstate);
33236 if (PyErr_Occurred()) SWIG_fail;
33237 }
33238 resultobj = SWIG_Py_Void();
33239 {
33240 if (temp2)
33241 delete arg2;
33242 }
33243 return resultobj;
33244 fail:
33245 {
33246 if (temp2)
33247 delete arg2;
33248 }
33249 return NULL;
33250 }
33251
33252
33253 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33254 PyObject *obj;
33255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33256 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33257 return SWIG_Py_Void();
33258 }
33259
33260 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33261 return SWIG_Python_InitShadowInstance(args);
33262 }
33263
33264 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33265 PyObject *resultobj = 0;
33266 wxDataFormat *arg1 = 0 ;
33267 wxCustomDataObject *result = 0 ;
33268 void *argp1 = 0 ;
33269 int res1 = 0 ;
33270
33271 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33273 if (!SWIG_IsOK(res1)) {
33274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33275 }
33276 if (!argp1) {
33277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33278 }
33279 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33280 {
33281 PyThreadState* __tstate = wxPyBeginAllowThreads();
33282 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33283 wxPyEndAllowThreads(__tstate);
33284 if (PyErr_Occurred()) SWIG_fail;
33285 }
33286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33287 return resultobj;
33288 fail:
33289 return NULL;
33290 }
33291
33292
33293 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33294 PyObject *resultobj = 0;
33295 wxString *arg1 = 0 ;
33296 wxCustomDataObject *result = 0 ;
33297 bool temp1 = false ;
33298
33299 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33300 {
33301 arg1 = wxString_in_helper(swig_obj[0]);
33302 if (arg1 == NULL) SWIG_fail;
33303 temp1 = true;
33304 }
33305 {
33306 PyThreadState* __tstate = wxPyBeginAllowThreads();
33307 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33308 wxPyEndAllowThreads(__tstate);
33309 if (PyErr_Occurred()) SWIG_fail;
33310 }
33311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33312 {
33313 if (temp1)
33314 delete arg1;
33315 }
33316 return resultobj;
33317 fail:
33318 {
33319 if (temp1)
33320 delete arg1;
33321 }
33322 return NULL;
33323 }
33324
33325
33326 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33327 PyObject *resultobj = 0;
33328 wxCustomDataObject *result = 0 ;
33329
33330 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33331 {
33332 PyThreadState* __tstate = wxPyBeginAllowThreads();
33333 result = (wxCustomDataObject *)new wxCustomDataObject();
33334 wxPyEndAllowThreads(__tstate);
33335 if (PyErr_Occurred()) SWIG_fail;
33336 }
33337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33338 return resultobj;
33339 fail:
33340 return NULL;
33341 }
33342
33343
33344 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33345 int argc;
33346 PyObject *argv[2];
33347
33348 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33349 --argc;
33350 if (argc == 0) {
33351 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33352 }
33353 if (argc == 1) {
33354 int _v = 0;
33355 {
33356 {
33357 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33358 }
33359 }
33360 if (!_v) goto check_2;
33361 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33362 }
33363 check_2:
33364
33365 if (argc == 1) {
33366 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33367 }
33368
33369 fail:
33370 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33371 return NULL;
33372 }
33373
33374
33375 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33376 PyObject *resultobj = 0;
33377 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33378 PyObject *arg2 = (PyObject *) 0 ;
33379 bool result;
33380 void *argp1 = 0 ;
33381 int res1 = 0 ;
33382 PyObject * obj0 = 0 ;
33383 PyObject * obj1 = 0 ;
33384 char * kwnames[] = {
33385 (char *) "self",(char *) "data", NULL
33386 };
33387
33388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33390 if (!SWIG_IsOK(res1)) {
33391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33392 }
33393 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33394 arg2 = obj1;
33395 {
33396 PyThreadState* __tstate = wxPyBeginAllowThreads();
33397 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33398 wxPyEndAllowThreads(__tstate);
33399 if (PyErr_Occurred()) SWIG_fail;
33400 }
33401 {
33402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33403 }
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33411 PyObject *resultobj = 0;
33412 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33413 size_t result;
33414 void *argp1 = 0 ;
33415 int res1 = 0 ;
33416 PyObject *swig_obj[1] ;
33417
33418 if (!args) SWIG_fail;
33419 swig_obj[0] = args;
33420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33421 if (!SWIG_IsOK(res1)) {
33422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33423 }
33424 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (size_t)(arg1)->GetSize();
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33439 PyObject *resultobj = 0;
33440 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33441 PyObject *result = 0 ;
33442 void *argp1 = 0 ;
33443 int res1 = 0 ;
33444 PyObject *swig_obj[1] ;
33445
33446 if (!args) SWIG_fail;
33447 swig_obj[0] = args;
33448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33449 if (!SWIG_IsOK(res1)) {
33450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33451 }
33452 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33453 {
33454 PyThreadState* __tstate = wxPyBeginAllowThreads();
33455 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33456 wxPyEndAllowThreads(__tstate);
33457 if (PyErr_Occurred()) SWIG_fail;
33458 }
33459 resultobj = result;
33460 return resultobj;
33461 fail:
33462 return NULL;
33463 }
33464
33465
33466 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33467 PyObject *obj;
33468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33469 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33470 return SWIG_Py_Void();
33471 }
33472
33473 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33474 return SWIG_Python_InitShadowInstance(args);
33475 }
33476
33477 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33478 PyObject *resultobj = 0;
33479 wxString const &arg1_defvalue = wxPyEmptyString ;
33480 wxString *arg1 = (wxString *) &arg1_defvalue ;
33481 wxURLDataObject *result = 0 ;
33482 bool temp1 = false ;
33483 PyObject * obj0 = 0 ;
33484 char * kwnames[] = {
33485 (char *) "url", NULL
33486 };
33487
33488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33489 if (obj0) {
33490 {
33491 arg1 = wxString_in_helper(obj0);
33492 if (arg1 == NULL) SWIG_fail;
33493 temp1 = true;
33494 }
33495 }
33496 {
33497 PyThreadState* __tstate = wxPyBeginAllowThreads();
33498 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33499 wxPyEndAllowThreads(__tstate);
33500 if (PyErr_Occurred()) SWIG_fail;
33501 }
33502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33503 {
33504 if (temp1)
33505 delete arg1;
33506 }
33507 return resultobj;
33508 fail:
33509 {
33510 if (temp1)
33511 delete arg1;
33512 }
33513 return NULL;
33514 }
33515
33516
33517 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33518 PyObject *resultobj = 0;
33519 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33520 wxString result;
33521 void *argp1 = 0 ;
33522 int res1 = 0 ;
33523 PyObject *swig_obj[1] ;
33524
33525 if (!args) SWIG_fail;
33526 swig_obj[0] = args;
33527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33528 if (!SWIG_IsOK(res1)) {
33529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33530 }
33531 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33532 {
33533 PyThreadState* __tstate = wxPyBeginAllowThreads();
33534 result = (arg1)->GetURL();
33535 wxPyEndAllowThreads(__tstate);
33536 if (PyErr_Occurred()) SWIG_fail;
33537 }
33538 {
33539 #if wxUSE_UNICODE
33540 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33541 #else
33542 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33543 #endif
33544 }
33545 return resultobj;
33546 fail:
33547 return NULL;
33548 }
33549
33550
33551 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33552 PyObject *resultobj = 0;
33553 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33554 wxString *arg2 = 0 ;
33555 void *argp1 = 0 ;
33556 int res1 = 0 ;
33557 bool temp2 = false ;
33558 PyObject * obj0 = 0 ;
33559 PyObject * obj1 = 0 ;
33560 char * kwnames[] = {
33561 (char *) "self",(char *) "url", NULL
33562 };
33563
33564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33566 if (!SWIG_IsOK(res1)) {
33567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33568 }
33569 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33570 {
33571 arg2 = wxString_in_helper(obj1);
33572 if (arg2 == NULL) SWIG_fail;
33573 temp2 = true;
33574 }
33575 {
33576 PyThreadState* __tstate = wxPyBeginAllowThreads();
33577 (arg1)->SetURL((wxString const &)*arg2);
33578 wxPyEndAllowThreads(__tstate);
33579 if (PyErr_Occurred()) SWIG_fail;
33580 }
33581 resultobj = SWIG_Py_Void();
33582 {
33583 if (temp2)
33584 delete arg2;
33585 }
33586 return resultobj;
33587 fail:
33588 {
33589 if (temp2)
33590 delete arg2;
33591 }
33592 return NULL;
33593 }
33594
33595
33596 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33597 PyObject *obj;
33598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33599 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33600 return SWIG_Py_Void();
33601 }
33602
33603 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33604 return SWIG_Python_InitShadowInstance(args);
33605 }
33606
33607 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33608 PyObject *resultobj = 0;
33609 wxMetafileDataObject *result = 0 ;
33610
33611 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33612 {
33613 PyThreadState* __tstate = wxPyBeginAllowThreads();
33614 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33615 wxPyEndAllowThreads(__tstate);
33616 if (PyErr_Occurred()) SWIG_fail;
33617 }
33618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33619 return resultobj;
33620 fail:
33621 return NULL;
33622 }
33623
33624
33625 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33626 PyObject *resultobj = 0;
33627 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33628 wxMetafile *arg2 = 0 ;
33629 void *argp1 = 0 ;
33630 int res1 = 0 ;
33631 void *argp2 = 0 ;
33632 int res2 = 0 ;
33633 PyObject * obj0 = 0 ;
33634 PyObject * obj1 = 0 ;
33635 char * kwnames[] = {
33636 (char *) "self",(char *) "metafile", NULL
33637 };
33638
33639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33641 if (!SWIG_IsOK(res1)) {
33642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33643 }
33644 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33645 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33646 if (!SWIG_IsOK(res2)) {
33647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33648 }
33649 if (!argp2) {
33650 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33651 }
33652 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33653 {
33654 PyThreadState* __tstate = wxPyBeginAllowThreads();
33655 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33656 wxPyEndAllowThreads(__tstate);
33657 if (PyErr_Occurred()) SWIG_fail;
33658 }
33659 resultobj = SWIG_Py_Void();
33660 return resultobj;
33661 fail:
33662 return NULL;
33663 }
33664
33665
33666 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33667 PyObject *resultobj = 0;
33668 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33669 wxMetafile result;
33670 void *argp1 = 0 ;
33671 int res1 = 0 ;
33672 PyObject *swig_obj[1] ;
33673
33674 if (!args) SWIG_fail;
33675 swig_obj[0] = args;
33676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33677 if (!SWIG_IsOK(res1)) {
33678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33679 }
33680 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33681 {
33682 PyThreadState* __tstate = wxPyBeginAllowThreads();
33683 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33684 wxPyEndAllowThreads(__tstate);
33685 if (PyErr_Occurred()) SWIG_fail;
33686 }
33687 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33688 return resultobj;
33689 fail:
33690 return NULL;
33691 }
33692
33693
33694 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33695 PyObject *obj;
33696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33697 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33698 return SWIG_Py_Void();
33699 }
33700
33701 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33702 return SWIG_Python_InitShadowInstance(args);
33703 }
33704
33705 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33706 PyObject *resultobj = 0;
33707 wxDragResult arg1 ;
33708 bool result;
33709 int val1 ;
33710 int ecode1 = 0 ;
33711 PyObject * obj0 = 0 ;
33712 char * kwnames[] = {
33713 (char *) "res", NULL
33714 };
33715
33716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33717 ecode1 = SWIG_AsVal_int(obj0, &val1);
33718 if (!SWIG_IsOK(ecode1)) {
33719 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33720 }
33721 arg1 = static_cast< wxDragResult >(val1);
33722 {
33723 PyThreadState* __tstate = wxPyBeginAllowThreads();
33724 result = (bool)wxIsDragResultOk(arg1);
33725 wxPyEndAllowThreads(__tstate);
33726 if (PyErr_Occurred()) SWIG_fail;
33727 }
33728 {
33729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33730 }
33731 return resultobj;
33732 fail:
33733 return NULL;
33734 }
33735
33736
33737 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33738 PyObject *resultobj = 0;
33739 wxWindow *arg1 = (wxWindow *) 0 ;
33740 wxCursor const &arg2_defvalue = wxNullCursor ;
33741 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33742 wxCursor const &arg3_defvalue = wxNullCursor ;
33743 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33744 wxCursor const &arg4_defvalue = wxNullCursor ;
33745 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33746 wxPyDropSource *result = 0 ;
33747 void *argp1 = 0 ;
33748 int res1 = 0 ;
33749 void *argp2 = 0 ;
33750 int res2 = 0 ;
33751 void *argp3 = 0 ;
33752 int res3 = 0 ;
33753 void *argp4 = 0 ;
33754 int res4 = 0 ;
33755 PyObject * obj0 = 0 ;
33756 PyObject * obj1 = 0 ;
33757 PyObject * obj2 = 0 ;
33758 PyObject * obj3 = 0 ;
33759 char * kwnames[] = {
33760 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33761 };
33762
33763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33765 if (!SWIG_IsOK(res1)) {
33766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33767 }
33768 arg1 = reinterpret_cast< wxWindow * >(argp1);
33769 if (obj1) {
33770 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33771 if (!SWIG_IsOK(res2)) {
33772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33773 }
33774 if (!argp2) {
33775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33776 }
33777 arg2 = reinterpret_cast< wxCursor * >(argp2);
33778 }
33779 if (obj2) {
33780 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33781 if (!SWIG_IsOK(res3)) {
33782 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33783 }
33784 if (!argp3) {
33785 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33786 }
33787 arg3 = reinterpret_cast< wxCursor * >(argp3);
33788 }
33789 if (obj3) {
33790 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33791 if (!SWIG_IsOK(res4)) {
33792 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33793 }
33794 if (!argp4) {
33795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33796 }
33797 arg4 = reinterpret_cast< wxCursor * >(argp4);
33798 }
33799 {
33800 PyThreadState* __tstate = wxPyBeginAllowThreads();
33801 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33802 wxPyEndAllowThreads(__tstate);
33803 if (PyErr_Occurred()) SWIG_fail;
33804 }
33805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33806 return resultobj;
33807 fail:
33808 return NULL;
33809 }
33810
33811
33812 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33813 PyObject *resultobj = 0;
33814 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33815 PyObject *arg2 = (PyObject *) 0 ;
33816 PyObject *arg3 = (PyObject *) 0 ;
33817 int arg4 = (int) 0 ;
33818 void *argp1 = 0 ;
33819 int res1 = 0 ;
33820 int val4 ;
33821 int ecode4 = 0 ;
33822 PyObject * obj0 = 0 ;
33823 PyObject * obj1 = 0 ;
33824 PyObject * obj2 = 0 ;
33825 PyObject * obj3 = 0 ;
33826 char * kwnames[] = {
33827 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33828 };
33829
33830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33832 if (!SWIG_IsOK(res1)) {
33833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33834 }
33835 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33836 arg2 = obj1;
33837 arg3 = obj2;
33838 if (obj3) {
33839 ecode4 = SWIG_AsVal_int(obj3, &val4);
33840 if (!SWIG_IsOK(ecode4)) {
33841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33842 }
33843 arg4 = static_cast< int >(val4);
33844 }
33845 {
33846 PyThreadState* __tstate = wxPyBeginAllowThreads();
33847 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33848 wxPyEndAllowThreads(__tstate);
33849 if (PyErr_Occurred()) SWIG_fail;
33850 }
33851 resultobj = SWIG_Py_Void();
33852 return resultobj;
33853 fail:
33854 return NULL;
33855 }
33856
33857
33858 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33859 PyObject *resultobj = 0;
33860 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33861 void *argp1 = 0 ;
33862 int res1 = 0 ;
33863 PyObject *swig_obj[1] ;
33864
33865 if (!args) SWIG_fail;
33866 swig_obj[0] = args;
33867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33868 if (!SWIG_IsOK(res1)) {
33869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33870 }
33871 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33872 {
33873 PyThreadState* __tstate = wxPyBeginAllowThreads();
33874 delete arg1;
33875
33876 wxPyEndAllowThreads(__tstate);
33877 if (PyErr_Occurred()) SWIG_fail;
33878 }
33879 resultobj = SWIG_Py_Void();
33880 return resultobj;
33881 fail:
33882 return NULL;
33883 }
33884
33885
33886 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33887 PyObject *resultobj = 0;
33888 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33889 wxDataObject *arg2 = 0 ;
33890 void *argp1 = 0 ;
33891 int res1 = 0 ;
33892 void *argp2 = 0 ;
33893 int res2 = 0 ;
33894 PyObject * obj0 = 0 ;
33895 PyObject * obj1 = 0 ;
33896 char * kwnames[] = {
33897 (char *) "self",(char *) "data", NULL
33898 };
33899
33900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33902 if (!SWIG_IsOK(res1)) {
33903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33904 }
33905 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33906 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33907 if (!SWIG_IsOK(res2)) {
33908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33909 }
33910 if (!argp2) {
33911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33912 }
33913 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 (arg1)->SetData(*arg2);
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 resultobj = SWIG_Py_Void();
33921 return resultobj;
33922 fail:
33923 return NULL;
33924 }
33925
33926
33927 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33928 PyObject *resultobj = 0;
33929 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33930 wxDataObject *result = 0 ;
33931 void *argp1 = 0 ;
33932 int res1 = 0 ;
33933 PyObject *swig_obj[1] ;
33934
33935 if (!args) SWIG_fail;
33936 swig_obj[0] = args;
33937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33938 if (!SWIG_IsOK(res1)) {
33939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33940 }
33941 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33942 {
33943 PyThreadState* __tstate = wxPyBeginAllowThreads();
33944 result = (wxDataObject *)(arg1)->GetDataObject();
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33949 return resultobj;
33950 fail:
33951 return NULL;
33952 }
33953
33954
33955 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33956 PyObject *resultobj = 0;
33957 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33958 wxDragResult arg2 ;
33959 wxCursor *arg3 = 0 ;
33960 void *argp1 = 0 ;
33961 int res1 = 0 ;
33962 int val2 ;
33963 int ecode2 = 0 ;
33964 void *argp3 = 0 ;
33965 int res3 = 0 ;
33966 PyObject * obj0 = 0 ;
33967 PyObject * obj1 = 0 ;
33968 PyObject * obj2 = 0 ;
33969 char * kwnames[] = {
33970 (char *) "self",(char *) "res",(char *) "cursor", NULL
33971 };
33972
33973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33975 if (!SWIG_IsOK(res1)) {
33976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33977 }
33978 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33979 ecode2 = SWIG_AsVal_int(obj1, &val2);
33980 if (!SWIG_IsOK(ecode2)) {
33981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33982 }
33983 arg2 = static_cast< wxDragResult >(val2);
33984 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33985 if (!SWIG_IsOK(res3)) {
33986 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33987 }
33988 if (!argp3) {
33989 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33990 }
33991 arg3 = reinterpret_cast< wxCursor * >(argp3);
33992 {
33993 PyThreadState* __tstate = wxPyBeginAllowThreads();
33994 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 resultobj = SWIG_Py_Void();
33999 return resultobj;
34000 fail:
34001 return NULL;
34002 }
34003
34004
34005 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34006 PyObject *resultobj = 0;
34007 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34008 int arg2 = (int) wxDrag_CopyOnly ;
34009 wxDragResult result;
34010 void *argp1 = 0 ;
34011 int res1 = 0 ;
34012 int val2 ;
34013 int ecode2 = 0 ;
34014 PyObject * obj0 = 0 ;
34015 PyObject * obj1 = 0 ;
34016 char * kwnames[] = {
34017 (char *) "self",(char *) "flags", NULL
34018 };
34019
34020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34022 if (!SWIG_IsOK(res1)) {
34023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34024 }
34025 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34026 if (obj1) {
34027 ecode2 = SWIG_AsVal_int(obj1, &val2);
34028 if (!SWIG_IsOK(ecode2)) {
34029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34030 }
34031 arg2 = static_cast< int >(val2);
34032 }
34033 {
34034 PyThreadState* __tstate = wxPyBeginAllowThreads();
34035 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34036 wxPyEndAllowThreads(__tstate);
34037 if (PyErr_Occurred()) SWIG_fail;
34038 }
34039 resultobj = SWIG_From_int(static_cast< int >(result));
34040 return resultobj;
34041 fail:
34042 return NULL;
34043 }
34044
34045
34046 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34047 PyObject *resultobj = 0;
34048 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34049 wxDragResult arg2 ;
34050 bool result;
34051 void *argp1 = 0 ;
34052 int res1 = 0 ;
34053 int val2 ;
34054 int ecode2 = 0 ;
34055 PyObject * obj0 = 0 ;
34056 PyObject * obj1 = 0 ;
34057 char * kwnames[] = {
34058 (char *) "self",(char *) "effect", NULL
34059 };
34060
34061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34063 if (!SWIG_IsOK(res1)) {
34064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34065 }
34066 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34067 ecode2 = SWIG_AsVal_int(obj1, &val2);
34068 if (!SWIG_IsOK(ecode2)) {
34069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34070 }
34071 arg2 = static_cast< wxDragResult >(val2);
34072 {
34073 PyThreadState* __tstate = wxPyBeginAllowThreads();
34074 result = (bool)(arg1)->GiveFeedback(arg2);
34075 wxPyEndAllowThreads(__tstate);
34076 if (PyErr_Occurred()) SWIG_fail;
34077 }
34078 {
34079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34080 }
34081 return resultobj;
34082 fail:
34083 return NULL;
34084 }
34085
34086
34087 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34088 PyObject *obj;
34089 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34090 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34091 return SWIG_Py_Void();
34092 }
34093
34094 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34095 return SWIG_Python_InitShadowInstance(args);
34096 }
34097
34098 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34099 PyObject *resultobj = 0;
34100 wxDataObject *arg1 = (wxDataObject *) NULL ;
34101 wxPyDropTarget *result = 0 ;
34102 int res1 = 0 ;
34103 PyObject * obj0 = 0 ;
34104 char * kwnames[] = {
34105 (char *) "dataObject", NULL
34106 };
34107
34108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34109 if (obj0) {
34110 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34111 if (!SWIG_IsOK(res1)) {
34112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34113 }
34114 }
34115 {
34116 PyThreadState* __tstate = wxPyBeginAllowThreads();
34117 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34118 wxPyEndAllowThreads(__tstate);
34119 if (PyErr_Occurred()) SWIG_fail;
34120 }
34121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34122 return resultobj;
34123 fail:
34124 return NULL;
34125 }
34126
34127
34128 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34129 PyObject *resultobj = 0;
34130 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34131 PyObject *arg2 = (PyObject *) 0 ;
34132 PyObject *arg3 = (PyObject *) 0 ;
34133 void *argp1 = 0 ;
34134 int res1 = 0 ;
34135 PyObject * obj0 = 0 ;
34136 PyObject * obj1 = 0 ;
34137 PyObject * obj2 = 0 ;
34138 char * kwnames[] = {
34139 (char *) "self",(char *) "self",(char *) "_class", NULL
34140 };
34141
34142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34144 if (!SWIG_IsOK(res1)) {
34145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34146 }
34147 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34148 arg2 = obj1;
34149 arg3 = obj2;
34150 {
34151 PyThreadState* __tstate = wxPyBeginAllowThreads();
34152 (arg1)->_setCallbackInfo(arg2,arg3);
34153 wxPyEndAllowThreads(__tstate);
34154 if (PyErr_Occurred()) SWIG_fail;
34155 }
34156 resultobj = SWIG_Py_Void();
34157 return resultobj;
34158 fail:
34159 return NULL;
34160 }
34161
34162
34163 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34164 PyObject *resultobj = 0;
34165 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34166 void *argp1 = 0 ;
34167 int res1 = 0 ;
34168 PyObject *swig_obj[1] ;
34169
34170 if (!args) SWIG_fail;
34171 swig_obj[0] = args;
34172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34173 if (!SWIG_IsOK(res1)) {
34174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34175 }
34176 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34177 {
34178 PyThreadState* __tstate = wxPyBeginAllowThreads();
34179 delete arg1;
34180
34181 wxPyEndAllowThreads(__tstate);
34182 if (PyErr_Occurred()) SWIG_fail;
34183 }
34184 resultobj = SWIG_Py_Void();
34185 return resultobj;
34186 fail:
34187 return NULL;
34188 }
34189
34190
34191 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34192 PyObject *resultobj = 0;
34193 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34194 wxDataObject *result = 0 ;
34195 void *argp1 = 0 ;
34196 int res1 = 0 ;
34197 PyObject *swig_obj[1] ;
34198
34199 if (!args) SWIG_fail;
34200 swig_obj[0] = args;
34201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34202 if (!SWIG_IsOK(res1)) {
34203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34204 }
34205 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34206 {
34207 PyThreadState* __tstate = wxPyBeginAllowThreads();
34208 result = (wxDataObject *)(arg1)->GetDataObject();
34209 wxPyEndAllowThreads(__tstate);
34210 if (PyErr_Occurred()) SWIG_fail;
34211 }
34212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34213 return resultobj;
34214 fail:
34215 return NULL;
34216 }
34217
34218
34219 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34220 PyObject *resultobj = 0;
34221 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34222 wxDataObject *arg2 = (wxDataObject *) 0 ;
34223 void *argp1 = 0 ;
34224 int res1 = 0 ;
34225 int res2 = 0 ;
34226 PyObject * obj0 = 0 ;
34227 PyObject * obj1 = 0 ;
34228 char * kwnames[] = {
34229 (char *) "self",(char *) "dataObject", NULL
34230 };
34231
34232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34234 if (!SWIG_IsOK(res1)) {
34235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34236 }
34237 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34238 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34239 if (!SWIG_IsOK(res2)) {
34240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34241 }
34242 {
34243 PyThreadState* __tstate = wxPyBeginAllowThreads();
34244 (arg1)->SetDataObject(arg2);
34245 wxPyEndAllowThreads(__tstate);
34246 if (PyErr_Occurred()) SWIG_fail;
34247 }
34248 resultobj = SWIG_Py_Void();
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34256 PyObject *resultobj = 0;
34257 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34258 int arg2 ;
34259 int arg3 ;
34260 wxDragResult arg4 ;
34261 wxDragResult result;
34262 void *argp1 = 0 ;
34263 int res1 = 0 ;
34264 int val2 ;
34265 int ecode2 = 0 ;
34266 int val3 ;
34267 int ecode3 = 0 ;
34268 int val4 ;
34269 int ecode4 = 0 ;
34270 PyObject * obj0 = 0 ;
34271 PyObject * obj1 = 0 ;
34272 PyObject * obj2 = 0 ;
34273 PyObject * obj3 = 0 ;
34274 char * kwnames[] = {
34275 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34276 };
34277
34278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34280 if (!SWIG_IsOK(res1)) {
34281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34282 }
34283 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34284 ecode2 = SWIG_AsVal_int(obj1, &val2);
34285 if (!SWIG_IsOK(ecode2)) {
34286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34287 }
34288 arg2 = static_cast< int >(val2);
34289 ecode3 = SWIG_AsVal_int(obj2, &val3);
34290 if (!SWIG_IsOK(ecode3)) {
34291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34292 }
34293 arg3 = static_cast< int >(val3);
34294 ecode4 = SWIG_AsVal_int(obj3, &val4);
34295 if (!SWIG_IsOK(ecode4)) {
34296 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34297 }
34298 arg4 = static_cast< wxDragResult >(val4);
34299 {
34300 PyThreadState* __tstate = wxPyBeginAllowThreads();
34301 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34302 wxPyEndAllowThreads(__tstate);
34303 if (PyErr_Occurred()) SWIG_fail;
34304 }
34305 resultobj = SWIG_From_int(static_cast< int >(result));
34306 return resultobj;
34307 fail:
34308 return NULL;
34309 }
34310
34311
34312 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34313 PyObject *resultobj = 0;
34314 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34315 int arg2 ;
34316 int arg3 ;
34317 wxDragResult arg4 ;
34318 wxDragResult result;
34319 void *argp1 = 0 ;
34320 int res1 = 0 ;
34321 int val2 ;
34322 int ecode2 = 0 ;
34323 int val3 ;
34324 int ecode3 = 0 ;
34325 int val4 ;
34326 int ecode4 = 0 ;
34327 PyObject * obj0 = 0 ;
34328 PyObject * obj1 = 0 ;
34329 PyObject * obj2 = 0 ;
34330 PyObject * obj3 = 0 ;
34331 char * kwnames[] = {
34332 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34333 };
34334
34335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34337 if (!SWIG_IsOK(res1)) {
34338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34339 }
34340 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34341 ecode2 = SWIG_AsVal_int(obj1, &val2);
34342 if (!SWIG_IsOK(ecode2)) {
34343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34344 }
34345 arg2 = static_cast< int >(val2);
34346 ecode3 = SWIG_AsVal_int(obj2, &val3);
34347 if (!SWIG_IsOK(ecode3)) {
34348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34349 }
34350 arg3 = static_cast< int >(val3);
34351 ecode4 = SWIG_AsVal_int(obj3, &val4);
34352 if (!SWIG_IsOK(ecode4)) {
34353 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34354 }
34355 arg4 = static_cast< wxDragResult >(val4);
34356 {
34357 PyThreadState* __tstate = wxPyBeginAllowThreads();
34358 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34359 wxPyEndAllowThreads(__tstate);
34360 if (PyErr_Occurred()) SWIG_fail;
34361 }
34362 resultobj = SWIG_From_int(static_cast< int >(result));
34363 return resultobj;
34364 fail:
34365 return NULL;
34366 }
34367
34368
34369 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34370 PyObject *resultobj = 0;
34371 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34372 void *argp1 = 0 ;
34373 int res1 = 0 ;
34374 PyObject *swig_obj[1] ;
34375
34376 if (!args) SWIG_fail;
34377 swig_obj[0] = args;
34378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34379 if (!SWIG_IsOK(res1)) {
34380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34381 }
34382 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34383 {
34384 PyThreadState* __tstate = wxPyBeginAllowThreads();
34385 (arg1)->OnLeave();
34386 wxPyEndAllowThreads(__tstate);
34387 if (PyErr_Occurred()) SWIG_fail;
34388 }
34389 resultobj = SWIG_Py_Void();
34390 return resultobj;
34391 fail:
34392 return NULL;
34393 }
34394
34395
34396 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34397 PyObject *resultobj = 0;
34398 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34399 int arg2 ;
34400 int arg3 ;
34401 bool result;
34402 void *argp1 = 0 ;
34403 int res1 = 0 ;
34404 int val2 ;
34405 int ecode2 = 0 ;
34406 int val3 ;
34407 int ecode3 = 0 ;
34408 PyObject * obj0 = 0 ;
34409 PyObject * obj1 = 0 ;
34410 PyObject * obj2 = 0 ;
34411 char * kwnames[] = {
34412 (char *) "self",(char *) "x",(char *) "y", NULL
34413 };
34414
34415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34417 if (!SWIG_IsOK(res1)) {
34418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34419 }
34420 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34421 ecode2 = SWIG_AsVal_int(obj1, &val2);
34422 if (!SWIG_IsOK(ecode2)) {
34423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34424 }
34425 arg2 = static_cast< int >(val2);
34426 ecode3 = SWIG_AsVal_int(obj2, &val3);
34427 if (!SWIG_IsOK(ecode3)) {
34428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34429 }
34430 arg3 = static_cast< int >(val3);
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 result = (bool)(arg1)->OnDrop(arg2,arg3);
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 {
34438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34439 }
34440 return resultobj;
34441 fail:
34442 return NULL;
34443 }
34444
34445
34446 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34447 PyObject *resultobj = 0;
34448 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34449 bool result;
34450 void *argp1 = 0 ;
34451 int res1 = 0 ;
34452 PyObject *swig_obj[1] ;
34453
34454 if (!args) SWIG_fail;
34455 swig_obj[0] = args;
34456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34457 if (!SWIG_IsOK(res1)) {
34458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34459 }
34460 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34461 {
34462 PyThreadState* __tstate = wxPyBeginAllowThreads();
34463 result = (bool)(arg1)->GetData();
34464 wxPyEndAllowThreads(__tstate);
34465 if (PyErr_Occurred()) SWIG_fail;
34466 }
34467 {
34468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34469 }
34470 return resultobj;
34471 fail:
34472 return NULL;
34473 }
34474
34475
34476 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34477 PyObject *resultobj = 0;
34478 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34479 wxDragResult arg2 ;
34480 void *argp1 = 0 ;
34481 int res1 = 0 ;
34482 int val2 ;
34483 int ecode2 = 0 ;
34484 PyObject * obj0 = 0 ;
34485 PyObject * obj1 = 0 ;
34486 char * kwnames[] = {
34487 (char *) "self",(char *) "action", NULL
34488 };
34489
34490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34492 if (!SWIG_IsOK(res1)) {
34493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34494 }
34495 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34496 ecode2 = SWIG_AsVal_int(obj1, &val2);
34497 if (!SWIG_IsOK(ecode2)) {
34498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34499 }
34500 arg2 = static_cast< wxDragResult >(val2);
34501 {
34502 PyThreadState* __tstate = wxPyBeginAllowThreads();
34503 (arg1)->SetDefaultAction(arg2);
34504 wxPyEndAllowThreads(__tstate);
34505 if (PyErr_Occurred()) SWIG_fail;
34506 }
34507 resultobj = SWIG_Py_Void();
34508 return resultobj;
34509 fail:
34510 return NULL;
34511 }
34512
34513
34514 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34515 PyObject *resultobj = 0;
34516 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34517 wxDragResult result;
34518 void *argp1 = 0 ;
34519 int res1 = 0 ;
34520 PyObject *swig_obj[1] ;
34521
34522 if (!args) SWIG_fail;
34523 swig_obj[0] = args;
34524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34525 if (!SWIG_IsOK(res1)) {
34526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34527 }
34528 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34529 {
34530 PyThreadState* __tstate = wxPyBeginAllowThreads();
34531 result = (wxDragResult)(arg1)->GetDefaultAction();
34532 wxPyEndAllowThreads(__tstate);
34533 if (PyErr_Occurred()) SWIG_fail;
34534 }
34535 resultobj = SWIG_From_int(static_cast< int >(result));
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34543 PyObject *obj;
34544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34545 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34546 return SWIG_Py_Void();
34547 }
34548
34549 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34550 return SWIG_Python_InitShadowInstance(args);
34551 }
34552
34553 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34554 PyObject *resultobj = 0;
34555 wxPyTextDropTarget *result = 0 ;
34556
34557 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34558 {
34559 PyThreadState* __tstate = wxPyBeginAllowThreads();
34560 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34561 wxPyEndAllowThreads(__tstate);
34562 if (PyErr_Occurred()) SWIG_fail;
34563 }
34564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34565 return resultobj;
34566 fail:
34567 return NULL;
34568 }
34569
34570
34571 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34572 PyObject *resultobj = 0;
34573 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34574 PyObject *arg2 = (PyObject *) 0 ;
34575 PyObject *arg3 = (PyObject *) 0 ;
34576 void *argp1 = 0 ;
34577 int res1 = 0 ;
34578 PyObject * obj0 = 0 ;
34579 PyObject * obj1 = 0 ;
34580 PyObject * obj2 = 0 ;
34581 char * kwnames[] = {
34582 (char *) "self",(char *) "self",(char *) "_class", NULL
34583 };
34584
34585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34587 if (!SWIG_IsOK(res1)) {
34588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34589 }
34590 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34591 arg2 = obj1;
34592 arg3 = obj2;
34593 {
34594 PyThreadState* __tstate = wxPyBeginAllowThreads();
34595 (arg1)->_setCallbackInfo(arg2,arg3);
34596 wxPyEndAllowThreads(__tstate);
34597 if (PyErr_Occurred()) SWIG_fail;
34598 }
34599 resultobj = SWIG_Py_Void();
34600 return resultobj;
34601 fail:
34602 return NULL;
34603 }
34604
34605
34606 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34607 PyObject *resultobj = 0;
34608 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34609 int arg2 ;
34610 int arg3 ;
34611 wxString *arg4 = 0 ;
34612 bool result;
34613 void *argp1 = 0 ;
34614 int res1 = 0 ;
34615 int val2 ;
34616 int ecode2 = 0 ;
34617 int val3 ;
34618 int ecode3 = 0 ;
34619 bool temp4 = false ;
34620 PyObject * obj0 = 0 ;
34621 PyObject * obj1 = 0 ;
34622 PyObject * obj2 = 0 ;
34623 PyObject * obj3 = 0 ;
34624 char * kwnames[] = {
34625 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34626 };
34627
34628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34630 if (!SWIG_IsOK(res1)) {
34631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34632 }
34633 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34634 ecode2 = SWIG_AsVal_int(obj1, &val2);
34635 if (!SWIG_IsOK(ecode2)) {
34636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34637 }
34638 arg2 = static_cast< int >(val2);
34639 ecode3 = SWIG_AsVal_int(obj2, &val3);
34640 if (!SWIG_IsOK(ecode3)) {
34641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34642 }
34643 arg3 = static_cast< int >(val3);
34644 {
34645 arg4 = wxString_in_helper(obj3);
34646 if (arg4 == NULL) SWIG_fail;
34647 temp4 = true;
34648 }
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 {
34656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34657 }
34658 {
34659 if (temp4)
34660 delete arg4;
34661 }
34662 return resultobj;
34663 fail:
34664 {
34665 if (temp4)
34666 delete arg4;
34667 }
34668 return NULL;
34669 }
34670
34671
34672 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34673 PyObject *resultobj = 0;
34674 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34675 int arg2 ;
34676 int arg3 ;
34677 wxDragResult arg4 ;
34678 wxDragResult result;
34679 void *argp1 = 0 ;
34680 int res1 = 0 ;
34681 int val2 ;
34682 int ecode2 = 0 ;
34683 int val3 ;
34684 int ecode3 = 0 ;
34685 int val4 ;
34686 int ecode4 = 0 ;
34687 PyObject * obj0 = 0 ;
34688 PyObject * obj1 = 0 ;
34689 PyObject * obj2 = 0 ;
34690 PyObject * obj3 = 0 ;
34691 char * kwnames[] = {
34692 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34693 };
34694
34695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34697 if (!SWIG_IsOK(res1)) {
34698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34699 }
34700 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34701 ecode2 = SWIG_AsVal_int(obj1, &val2);
34702 if (!SWIG_IsOK(ecode2)) {
34703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34704 }
34705 arg2 = static_cast< int >(val2);
34706 ecode3 = SWIG_AsVal_int(obj2, &val3);
34707 if (!SWIG_IsOK(ecode3)) {
34708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34709 }
34710 arg3 = static_cast< int >(val3);
34711 ecode4 = SWIG_AsVal_int(obj3, &val4);
34712 if (!SWIG_IsOK(ecode4)) {
34713 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34714 }
34715 arg4 = static_cast< wxDragResult >(val4);
34716 {
34717 PyThreadState* __tstate = wxPyBeginAllowThreads();
34718 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34719 wxPyEndAllowThreads(__tstate);
34720 if (PyErr_Occurred()) SWIG_fail;
34721 }
34722 resultobj = SWIG_From_int(static_cast< int >(result));
34723 return resultobj;
34724 fail:
34725 return NULL;
34726 }
34727
34728
34729 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34730 PyObject *resultobj = 0;
34731 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34732 int arg2 ;
34733 int arg3 ;
34734 wxDragResult arg4 ;
34735 wxDragResult result;
34736 void *argp1 = 0 ;
34737 int res1 = 0 ;
34738 int val2 ;
34739 int ecode2 = 0 ;
34740 int val3 ;
34741 int ecode3 = 0 ;
34742 int val4 ;
34743 int ecode4 = 0 ;
34744 PyObject * obj0 = 0 ;
34745 PyObject * obj1 = 0 ;
34746 PyObject * obj2 = 0 ;
34747 PyObject * obj3 = 0 ;
34748 char * kwnames[] = {
34749 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34750 };
34751
34752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34754 if (!SWIG_IsOK(res1)) {
34755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34756 }
34757 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34758 ecode2 = SWIG_AsVal_int(obj1, &val2);
34759 if (!SWIG_IsOK(ecode2)) {
34760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34761 }
34762 arg2 = static_cast< int >(val2);
34763 ecode3 = SWIG_AsVal_int(obj2, &val3);
34764 if (!SWIG_IsOK(ecode3)) {
34765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34766 }
34767 arg3 = static_cast< int >(val3);
34768 ecode4 = SWIG_AsVal_int(obj3, &val4);
34769 if (!SWIG_IsOK(ecode4)) {
34770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34771 }
34772 arg4 = static_cast< wxDragResult >(val4);
34773 {
34774 PyThreadState* __tstate = wxPyBeginAllowThreads();
34775 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34776 wxPyEndAllowThreads(__tstate);
34777 if (PyErr_Occurred()) SWIG_fail;
34778 }
34779 resultobj = SWIG_From_int(static_cast< int >(result));
34780 return resultobj;
34781 fail:
34782 return NULL;
34783 }
34784
34785
34786 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34787 PyObject *resultobj = 0;
34788 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34789 void *argp1 = 0 ;
34790 int res1 = 0 ;
34791 PyObject *swig_obj[1] ;
34792
34793 if (!args) SWIG_fail;
34794 swig_obj[0] = args;
34795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34796 if (!SWIG_IsOK(res1)) {
34797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34798 }
34799 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34800 {
34801 PyThreadState* __tstate = wxPyBeginAllowThreads();
34802 (arg1)->OnLeave();
34803 wxPyEndAllowThreads(__tstate);
34804 if (PyErr_Occurred()) SWIG_fail;
34805 }
34806 resultobj = SWIG_Py_Void();
34807 return resultobj;
34808 fail:
34809 return NULL;
34810 }
34811
34812
34813 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34814 PyObject *resultobj = 0;
34815 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34816 int arg2 ;
34817 int arg3 ;
34818 bool result;
34819 void *argp1 = 0 ;
34820 int res1 = 0 ;
34821 int val2 ;
34822 int ecode2 = 0 ;
34823 int val3 ;
34824 int ecode3 = 0 ;
34825 PyObject * obj0 = 0 ;
34826 PyObject * obj1 = 0 ;
34827 PyObject * obj2 = 0 ;
34828 char * kwnames[] = {
34829 (char *) "self",(char *) "x",(char *) "y", NULL
34830 };
34831
34832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34834 if (!SWIG_IsOK(res1)) {
34835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34836 }
34837 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34838 ecode2 = SWIG_AsVal_int(obj1, &val2);
34839 if (!SWIG_IsOK(ecode2)) {
34840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34841 }
34842 arg2 = static_cast< int >(val2);
34843 ecode3 = SWIG_AsVal_int(obj2, &val3);
34844 if (!SWIG_IsOK(ecode3)) {
34845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34846 }
34847 arg3 = static_cast< int >(val3);
34848 {
34849 PyThreadState* __tstate = wxPyBeginAllowThreads();
34850 result = (bool)(arg1)->OnDrop(arg2,arg3);
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 {
34855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34856 }
34857 return resultobj;
34858 fail:
34859 return NULL;
34860 }
34861
34862
34863 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34864 PyObject *resultobj = 0;
34865 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34866 int arg2 ;
34867 int arg3 ;
34868 wxDragResult arg4 ;
34869 wxDragResult result;
34870 void *argp1 = 0 ;
34871 int res1 = 0 ;
34872 int val2 ;
34873 int ecode2 = 0 ;
34874 int val3 ;
34875 int ecode3 = 0 ;
34876 int val4 ;
34877 int ecode4 = 0 ;
34878 PyObject * obj0 = 0 ;
34879 PyObject * obj1 = 0 ;
34880 PyObject * obj2 = 0 ;
34881 PyObject * obj3 = 0 ;
34882 char * kwnames[] = {
34883 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34884 };
34885
34886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34888 if (!SWIG_IsOK(res1)) {
34889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34890 }
34891 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34892 ecode2 = SWIG_AsVal_int(obj1, &val2);
34893 if (!SWIG_IsOK(ecode2)) {
34894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34895 }
34896 arg2 = static_cast< int >(val2);
34897 ecode3 = SWIG_AsVal_int(obj2, &val3);
34898 if (!SWIG_IsOK(ecode3)) {
34899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34900 }
34901 arg3 = static_cast< int >(val3);
34902 ecode4 = SWIG_AsVal_int(obj3, &val4);
34903 if (!SWIG_IsOK(ecode4)) {
34904 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34905 }
34906 arg4 = static_cast< wxDragResult >(val4);
34907 {
34908 PyThreadState* __tstate = wxPyBeginAllowThreads();
34909 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34910 wxPyEndAllowThreads(__tstate);
34911 if (PyErr_Occurred()) SWIG_fail;
34912 }
34913 resultobj = SWIG_From_int(static_cast< int >(result));
34914 return resultobj;
34915 fail:
34916 return NULL;
34917 }
34918
34919
34920 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34921 PyObject *obj;
34922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34923 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34924 return SWIG_Py_Void();
34925 }
34926
34927 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34928 return SWIG_Python_InitShadowInstance(args);
34929 }
34930
34931 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34932 PyObject *resultobj = 0;
34933 wxPyFileDropTarget *result = 0 ;
34934
34935 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34936 {
34937 PyThreadState* __tstate = wxPyBeginAllowThreads();
34938 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34939 wxPyEndAllowThreads(__tstate);
34940 if (PyErr_Occurred()) SWIG_fail;
34941 }
34942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34943 return resultobj;
34944 fail:
34945 return NULL;
34946 }
34947
34948
34949 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34950 PyObject *resultobj = 0;
34951 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34952 PyObject *arg2 = (PyObject *) 0 ;
34953 PyObject *arg3 = (PyObject *) 0 ;
34954 void *argp1 = 0 ;
34955 int res1 = 0 ;
34956 PyObject * obj0 = 0 ;
34957 PyObject * obj1 = 0 ;
34958 PyObject * obj2 = 0 ;
34959 char * kwnames[] = {
34960 (char *) "self",(char *) "self",(char *) "_class", NULL
34961 };
34962
34963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34965 if (!SWIG_IsOK(res1)) {
34966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34967 }
34968 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34969 arg2 = obj1;
34970 arg3 = obj2;
34971 {
34972 PyThreadState* __tstate = wxPyBeginAllowThreads();
34973 (arg1)->_setCallbackInfo(arg2,arg3);
34974 wxPyEndAllowThreads(__tstate);
34975 if (PyErr_Occurred()) SWIG_fail;
34976 }
34977 resultobj = SWIG_Py_Void();
34978 return resultobj;
34979 fail:
34980 return NULL;
34981 }
34982
34983
34984 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34985 PyObject *resultobj = 0;
34986 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34987 int arg2 ;
34988 int arg3 ;
34989 wxArrayString *arg4 = 0 ;
34990 bool result;
34991 void *argp1 = 0 ;
34992 int res1 = 0 ;
34993 int val2 ;
34994 int ecode2 = 0 ;
34995 int val3 ;
34996 int ecode3 = 0 ;
34997 bool temp4 = false ;
34998 PyObject * obj0 = 0 ;
34999 PyObject * obj1 = 0 ;
35000 PyObject * obj2 = 0 ;
35001 PyObject * obj3 = 0 ;
35002 char * kwnames[] = {
35003 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35004 };
35005
35006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35008 if (!SWIG_IsOK(res1)) {
35009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35010 }
35011 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35012 ecode2 = SWIG_AsVal_int(obj1, &val2);
35013 if (!SWIG_IsOK(ecode2)) {
35014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35015 }
35016 arg2 = static_cast< int >(val2);
35017 ecode3 = SWIG_AsVal_int(obj2, &val3);
35018 if (!SWIG_IsOK(ecode3)) {
35019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35020 }
35021 arg3 = static_cast< int >(val3);
35022 {
35023 if (! PySequence_Check(obj3)) {
35024 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35025 SWIG_fail;
35026 }
35027 arg4 = new wxArrayString;
35028 temp4 = true;
35029 int i, len=PySequence_Length(obj3);
35030 for (i=0; i<len; i++) {
35031 PyObject* item = PySequence_GetItem(obj3, i);
35032 wxString* s = wxString_in_helper(item);
35033 if (PyErr_Occurred()) SWIG_fail;
35034 arg4->Add(*s);
35035 delete s;
35036 Py_DECREF(item);
35037 }
35038 }
35039 {
35040 PyThreadState* __tstate = wxPyBeginAllowThreads();
35041 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35042 wxPyEndAllowThreads(__tstate);
35043 if (PyErr_Occurred()) SWIG_fail;
35044 }
35045 {
35046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35047 }
35048 {
35049 if (temp4) delete arg4;
35050 }
35051 return resultobj;
35052 fail:
35053 {
35054 if (temp4) delete arg4;
35055 }
35056 return NULL;
35057 }
35058
35059
35060 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35061 PyObject *resultobj = 0;
35062 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35063 int arg2 ;
35064 int arg3 ;
35065 wxDragResult arg4 ;
35066 wxDragResult result;
35067 void *argp1 = 0 ;
35068 int res1 = 0 ;
35069 int val2 ;
35070 int ecode2 = 0 ;
35071 int val3 ;
35072 int ecode3 = 0 ;
35073 int val4 ;
35074 int ecode4 = 0 ;
35075 PyObject * obj0 = 0 ;
35076 PyObject * obj1 = 0 ;
35077 PyObject * obj2 = 0 ;
35078 PyObject * obj3 = 0 ;
35079 char * kwnames[] = {
35080 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35081 };
35082
35083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35085 if (!SWIG_IsOK(res1)) {
35086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35087 }
35088 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35089 ecode2 = SWIG_AsVal_int(obj1, &val2);
35090 if (!SWIG_IsOK(ecode2)) {
35091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35092 }
35093 arg2 = static_cast< int >(val2);
35094 ecode3 = SWIG_AsVal_int(obj2, &val3);
35095 if (!SWIG_IsOK(ecode3)) {
35096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35097 }
35098 arg3 = static_cast< int >(val3);
35099 ecode4 = SWIG_AsVal_int(obj3, &val4);
35100 if (!SWIG_IsOK(ecode4)) {
35101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35102 }
35103 arg4 = static_cast< wxDragResult >(val4);
35104 {
35105 PyThreadState* __tstate = wxPyBeginAllowThreads();
35106 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35107 wxPyEndAllowThreads(__tstate);
35108 if (PyErr_Occurred()) SWIG_fail;
35109 }
35110 resultobj = SWIG_From_int(static_cast< int >(result));
35111 return resultobj;
35112 fail:
35113 return NULL;
35114 }
35115
35116
35117 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35118 PyObject *resultobj = 0;
35119 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35120 int arg2 ;
35121 int arg3 ;
35122 wxDragResult arg4 ;
35123 wxDragResult result;
35124 void *argp1 = 0 ;
35125 int res1 = 0 ;
35126 int val2 ;
35127 int ecode2 = 0 ;
35128 int val3 ;
35129 int ecode3 = 0 ;
35130 int val4 ;
35131 int ecode4 = 0 ;
35132 PyObject * obj0 = 0 ;
35133 PyObject * obj1 = 0 ;
35134 PyObject * obj2 = 0 ;
35135 PyObject * obj3 = 0 ;
35136 char * kwnames[] = {
35137 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35138 };
35139
35140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35142 if (!SWIG_IsOK(res1)) {
35143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35144 }
35145 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35146 ecode2 = SWIG_AsVal_int(obj1, &val2);
35147 if (!SWIG_IsOK(ecode2)) {
35148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35149 }
35150 arg2 = static_cast< int >(val2);
35151 ecode3 = SWIG_AsVal_int(obj2, &val3);
35152 if (!SWIG_IsOK(ecode3)) {
35153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35154 }
35155 arg3 = static_cast< int >(val3);
35156 ecode4 = SWIG_AsVal_int(obj3, &val4);
35157 if (!SWIG_IsOK(ecode4)) {
35158 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35159 }
35160 arg4 = static_cast< wxDragResult >(val4);
35161 {
35162 PyThreadState* __tstate = wxPyBeginAllowThreads();
35163 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35164 wxPyEndAllowThreads(__tstate);
35165 if (PyErr_Occurred()) SWIG_fail;
35166 }
35167 resultobj = SWIG_From_int(static_cast< int >(result));
35168 return resultobj;
35169 fail:
35170 return NULL;
35171 }
35172
35173
35174 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35175 PyObject *resultobj = 0;
35176 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35177 void *argp1 = 0 ;
35178 int res1 = 0 ;
35179 PyObject *swig_obj[1] ;
35180
35181 if (!args) SWIG_fail;
35182 swig_obj[0] = args;
35183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35184 if (!SWIG_IsOK(res1)) {
35185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35186 }
35187 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35188 {
35189 PyThreadState* __tstate = wxPyBeginAllowThreads();
35190 (arg1)->OnLeave();
35191 wxPyEndAllowThreads(__tstate);
35192 if (PyErr_Occurred()) SWIG_fail;
35193 }
35194 resultobj = SWIG_Py_Void();
35195 return resultobj;
35196 fail:
35197 return NULL;
35198 }
35199
35200
35201 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35202 PyObject *resultobj = 0;
35203 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35204 int arg2 ;
35205 int arg3 ;
35206 bool result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 int val2 ;
35210 int ecode2 = 0 ;
35211 int val3 ;
35212 int ecode3 = 0 ;
35213 PyObject * obj0 = 0 ;
35214 PyObject * obj1 = 0 ;
35215 PyObject * obj2 = 0 ;
35216 char * kwnames[] = {
35217 (char *) "self",(char *) "x",(char *) "y", NULL
35218 };
35219
35220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35222 if (!SWIG_IsOK(res1)) {
35223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35224 }
35225 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35226 ecode2 = SWIG_AsVal_int(obj1, &val2);
35227 if (!SWIG_IsOK(ecode2)) {
35228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35229 }
35230 arg2 = static_cast< int >(val2);
35231 ecode3 = SWIG_AsVal_int(obj2, &val3);
35232 if (!SWIG_IsOK(ecode3)) {
35233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35234 }
35235 arg3 = static_cast< int >(val3);
35236 {
35237 PyThreadState* __tstate = wxPyBeginAllowThreads();
35238 result = (bool)(arg1)->OnDrop(arg2,arg3);
35239 wxPyEndAllowThreads(__tstate);
35240 if (PyErr_Occurred()) SWIG_fail;
35241 }
35242 {
35243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35244 }
35245 return resultobj;
35246 fail:
35247 return NULL;
35248 }
35249
35250
35251 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35252 PyObject *resultobj = 0;
35253 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35254 int arg2 ;
35255 int arg3 ;
35256 wxDragResult arg4 ;
35257 wxDragResult result;
35258 void *argp1 = 0 ;
35259 int res1 = 0 ;
35260 int val2 ;
35261 int ecode2 = 0 ;
35262 int val3 ;
35263 int ecode3 = 0 ;
35264 int val4 ;
35265 int ecode4 = 0 ;
35266 PyObject * obj0 = 0 ;
35267 PyObject * obj1 = 0 ;
35268 PyObject * obj2 = 0 ;
35269 PyObject * obj3 = 0 ;
35270 char * kwnames[] = {
35271 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35272 };
35273
35274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35276 if (!SWIG_IsOK(res1)) {
35277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35278 }
35279 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35280 ecode2 = SWIG_AsVal_int(obj1, &val2);
35281 if (!SWIG_IsOK(ecode2)) {
35282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35283 }
35284 arg2 = static_cast< int >(val2);
35285 ecode3 = SWIG_AsVal_int(obj2, &val3);
35286 if (!SWIG_IsOK(ecode3)) {
35287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35288 }
35289 arg3 = static_cast< int >(val3);
35290 ecode4 = SWIG_AsVal_int(obj3, &val4);
35291 if (!SWIG_IsOK(ecode4)) {
35292 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35293 }
35294 arg4 = static_cast< wxDragResult >(val4);
35295 {
35296 PyThreadState* __tstate = wxPyBeginAllowThreads();
35297 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35298 wxPyEndAllowThreads(__tstate);
35299 if (PyErr_Occurred()) SWIG_fail;
35300 }
35301 resultobj = SWIG_From_int(static_cast< int >(result));
35302 return resultobj;
35303 fail:
35304 return NULL;
35305 }
35306
35307
35308 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35309 PyObject *obj;
35310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35311 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35312 return SWIG_Py_Void();
35313 }
35314
35315 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35316 return SWIG_Python_InitShadowInstance(args);
35317 }
35318
35319 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35320 PyObject *resultobj = 0;
35321 wxClipboard *result = 0 ;
35322
35323 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35324 {
35325 PyThreadState* __tstate = wxPyBeginAllowThreads();
35326 result = (wxClipboard *)new wxClipboard();
35327 wxPyEndAllowThreads(__tstate);
35328 if (PyErr_Occurred()) SWIG_fail;
35329 }
35330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35331 return resultobj;
35332 fail:
35333 return NULL;
35334 }
35335
35336
35337 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35338 PyObject *resultobj = 0;
35339 wxClipboard *arg1 = (wxClipboard *) 0 ;
35340 void *argp1 = 0 ;
35341 int res1 = 0 ;
35342 PyObject *swig_obj[1] ;
35343
35344 if (!args) SWIG_fail;
35345 swig_obj[0] = args;
35346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35347 if (!SWIG_IsOK(res1)) {
35348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35349 }
35350 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35351 {
35352 PyThreadState* __tstate = wxPyBeginAllowThreads();
35353 delete arg1;
35354
35355 wxPyEndAllowThreads(__tstate);
35356 if (PyErr_Occurred()) SWIG_fail;
35357 }
35358 resultobj = SWIG_Py_Void();
35359 return resultobj;
35360 fail:
35361 return NULL;
35362 }
35363
35364
35365 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35366 PyObject *resultobj = 0;
35367 wxClipboard *arg1 = (wxClipboard *) 0 ;
35368 bool result;
35369 void *argp1 = 0 ;
35370 int res1 = 0 ;
35371 PyObject *swig_obj[1] ;
35372
35373 if (!args) SWIG_fail;
35374 swig_obj[0] = args;
35375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35376 if (!SWIG_IsOK(res1)) {
35377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35378 }
35379 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35380 {
35381 PyThreadState* __tstate = wxPyBeginAllowThreads();
35382 result = (bool)(arg1)->Open();
35383 wxPyEndAllowThreads(__tstate);
35384 if (PyErr_Occurred()) SWIG_fail;
35385 }
35386 {
35387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35388 }
35389 return resultobj;
35390 fail:
35391 return NULL;
35392 }
35393
35394
35395 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35396 PyObject *resultobj = 0;
35397 wxClipboard *arg1 = (wxClipboard *) 0 ;
35398 void *argp1 = 0 ;
35399 int res1 = 0 ;
35400 PyObject *swig_obj[1] ;
35401
35402 if (!args) SWIG_fail;
35403 swig_obj[0] = args;
35404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35405 if (!SWIG_IsOK(res1)) {
35406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35407 }
35408 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35409 {
35410 PyThreadState* __tstate = wxPyBeginAllowThreads();
35411 (arg1)->Close();
35412 wxPyEndAllowThreads(__tstate);
35413 if (PyErr_Occurred()) SWIG_fail;
35414 }
35415 resultobj = SWIG_Py_Void();
35416 return resultobj;
35417 fail:
35418 return NULL;
35419 }
35420
35421
35422 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35423 PyObject *resultobj = 0;
35424 wxClipboard *arg1 = (wxClipboard *) 0 ;
35425 bool result;
35426 void *argp1 = 0 ;
35427 int res1 = 0 ;
35428 PyObject *swig_obj[1] ;
35429
35430 if (!args) SWIG_fail;
35431 swig_obj[0] = args;
35432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35433 if (!SWIG_IsOK(res1)) {
35434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35435 }
35436 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35437 {
35438 PyThreadState* __tstate = wxPyBeginAllowThreads();
35439 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35440 wxPyEndAllowThreads(__tstate);
35441 if (PyErr_Occurred()) SWIG_fail;
35442 }
35443 {
35444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35445 }
35446 return resultobj;
35447 fail:
35448 return NULL;
35449 }
35450
35451
35452 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35453 PyObject *resultobj = 0;
35454 wxClipboard *arg1 = (wxClipboard *) 0 ;
35455 wxDataObject *arg2 = (wxDataObject *) 0 ;
35456 bool result;
35457 void *argp1 = 0 ;
35458 int res1 = 0 ;
35459 int res2 = 0 ;
35460 PyObject * obj0 = 0 ;
35461 PyObject * obj1 = 0 ;
35462 char * kwnames[] = {
35463 (char *) "self",(char *) "data", NULL
35464 };
35465
35466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35468 if (!SWIG_IsOK(res1)) {
35469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35470 }
35471 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35472 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35473 if (!SWIG_IsOK(res2)) {
35474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35475 }
35476 {
35477 PyThreadState* __tstate = wxPyBeginAllowThreads();
35478 result = (bool)(arg1)->AddData(arg2);
35479 wxPyEndAllowThreads(__tstate);
35480 if (PyErr_Occurred()) SWIG_fail;
35481 }
35482 {
35483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35484 }
35485 return resultobj;
35486 fail:
35487 return NULL;
35488 }
35489
35490
35491 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35492 PyObject *resultobj = 0;
35493 wxClipboard *arg1 = (wxClipboard *) 0 ;
35494 wxDataObject *arg2 = (wxDataObject *) 0 ;
35495 bool result;
35496 void *argp1 = 0 ;
35497 int res1 = 0 ;
35498 int res2 = 0 ;
35499 PyObject * obj0 = 0 ;
35500 PyObject * obj1 = 0 ;
35501 char * kwnames[] = {
35502 (char *) "self",(char *) "data", NULL
35503 };
35504
35505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35507 if (!SWIG_IsOK(res1)) {
35508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35509 }
35510 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35511 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35512 if (!SWIG_IsOK(res2)) {
35513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35514 }
35515 {
35516 PyThreadState* __tstate = wxPyBeginAllowThreads();
35517 result = (bool)(arg1)->SetData(arg2);
35518 wxPyEndAllowThreads(__tstate);
35519 if (PyErr_Occurred()) SWIG_fail;
35520 }
35521 {
35522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35523 }
35524 return resultobj;
35525 fail:
35526 return NULL;
35527 }
35528
35529
35530 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35531 PyObject *resultobj = 0;
35532 wxClipboard *arg1 = (wxClipboard *) 0 ;
35533 wxDataFormat *arg2 = 0 ;
35534 bool result;
35535 void *argp1 = 0 ;
35536 int res1 = 0 ;
35537 void *argp2 = 0 ;
35538 int res2 = 0 ;
35539 PyObject * obj0 = 0 ;
35540 PyObject * obj1 = 0 ;
35541 char * kwnames[] = {
35542 (char *) "self",(char *) "format", NULL
35543 };
35544
35545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35547 if (!SWIG_IsOK(res1)) {
35548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35549 }
35550 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35551 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35552 if (!SWIG_IsOK(res2)) {
35553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35554 }
35555 if (!argp2) {
35556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35557 }
35558 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35559 {
35560 PyThreadState* __tstate = wxPyBeginAllowThreads();
35561 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35562 wxPyEndAllowThreads(__tstate);
35563 if (PyErr_Occurred()) SWIG_fail;
35564 }
35565 {
35566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35567 }
35568 return resultobj;
35569 fail:
35570 return NULL;
35571 }
35572
35573
35574 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35575 PyObject *resultobj = 0;
35576 wxClipboard *arg1 = (wxClipboard *) 0 ;
35577 wxDataObject *arg2 = 0 ;
35578 bool result;
35579 void *argp1 = 0 ;
35580 int res1 = 0 ;
35581 void *argp2 = 0 ;
35582 int res2 = 0 ;
35583 PyObject * obj0 = 0 ;
35584 PyObject * obj1 = 0 ;
35585 char * kwnames[] = {
35586 (char *) "self",(char *) "data", NULL
35587 };
35588
35589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35591 if (!SWIG_IsOK(res1)) {
35592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35593 }
35594 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35595 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35596 if (!SWIG_IsOK(res2)) {
35597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35598 }
35599 if (!argp2) {
35600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35601 }
35602 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35603 {
35604 PyThreadState* __tstate = wxPyBeginAllowThreads();
35605 result = (bool)(arg1)->GetData(*arg2);
35606 wxPyEndAllowThreads(__tstate);
35607 if (PyErr_Occurred()) SWIG_fail;
35608 }
35609 {
35610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35611 }
35612 return resultobj;
35613 fail:
35614 return NULL;
35615 }
35616
35617
35618 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35619 PyObject *resultobj = 0;
35620 wxClipboard *arg1 = (wxClipboard *) 0 ;
35621 void *argp1 = 0 ;
35622 int res1 = 0 ;
35623 PyObject *swig_obj[1] ;
35624
35625 if (!args) SWIG_fail;
35626 swig_obj[0] = args;
35627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35628 if (!SWIG_IsOK(res1)) {
35629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35630 }
35631 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35632 {
35633 PyThreadState* __tstate = wxPyBeginAllowThreads();
35634 (arg1)->Clear();
35635 wxPyEndAllowThreads(__tstate);
35636 if (PyErr_Occurred()) SWIG_fail;
35637 }
35638 resultobj = SWIG_Py_Void();
35639 return resultobj;
35640 fail:
35641 return NULL;
35642 }
35643
35644
35645 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35646 PyObject *resultobj = 0;
35647 wxClipboard *arg1 = (wxClipboard *) 0 ;
35648 bool result;
35649 void *argp1 = 0 ;
35650 int res1 = 0 ;
35651 PyObject *swig_obj[1] ;
35652
35653 if (!args) SWIG_fail;
35654 swig_obj[0] = args;
35655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35656 if (!SWIG_IsOK(res1)) {
35657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35658 }
35659 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35660 {
35661 PyThreadState* __tstate = wxPyBeginAllowThreads();
35662 result = (bool)(arg1)->Flush();
35663 wxPyEndAllowThreads(__tstate);
35664 if (PyErr_Occurred()) SWIG_fail;
35665 }
35666 {
35667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35668 }
35669 return resultobj;
35670 fail:
35671 return NULL;
35672 }
35673
35674
35675 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35676 PyObject *resultobj = 0;
35677 wxClipboard *arg1 = (wxClipboard *) 0 ;
35678 bool arg2 = (bool) true ;
35679 void *argp1 = 0 ;
35680 int res1 = 0 ;
35681 bool val2 ;
35682 int ecode2 = 0 ;
35683 PyObject * obj0 = 0 ;
35684 PyObject * obj1 = 0 ;
35685 char * kwnames[] = {
35686 (char *) "self",(char *) "primary", NULL
35687 };
35688
35689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35691 if (!SWIG_IsOK(res1)) {
35692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35693 }
35694 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35695 if (obj1) {
35696 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35697 if (!SWIG_IsOK(ecode2)) {
35698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35699 }
35700 arg2 = static_cast< bool >(val2);
35701 }
35702 {
35703 PyThreadState* __tstate = wxPyBeginAllowThreads();
35704 (arg1)->UsePrimarySelection(arg2);
35705 wxPyEndAllowThreads(__tstate);
35706 if (PyErr_Occurred()) SWIG_fail;
35707 }
35708 resultobj = SWIG_Py_Void();
35709 return resultobj;
35710 fail:
35711 return NULL;
35712 }
35713
35714
35715 SWIGINTERN PyObject *_wrap_Clipboard_IsUsingPrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35716 PyObject *resultobj = 0;
35717 wxClipboard *arg1 = (wxClipboard *) 0 ;
35718 bool result;
35719 void *argp1 = 0 ;
35720 int res1 = 0 ;
35721 PyObject *swig_obj[1] ;
35722
35723 if (!args) SWIG_fail;
35724 swig_obj[0] = args;
35725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35726 if (!SWIG_IsOK(res1)) {
35727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsUsingPrimarySelection" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35728 }
35729 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35730 {
35731 PyThreadState* __tstate = wxPyBeginAllowThreads();
35732 result = (bool)((wxClipboard const *)arg1)->IsUsingPrimarySelection();
35733 wxPyEndAllowThreads(__tstate);
35734 if (PyErr_Occurred()) SWIG_fail;
35735 }
35736 {
35737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35738 }
35739 return resultobj;
35740 fail:
35741 return NULL;
35742 }
35743
35744
35745 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35746 PyObject *resultobj = 0;
35747 wxClipboard *result = 0 ;
35748
35749 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35750 {
35751 PyThreadState* __tstate = wxPyBeginAllowThreads();
35752 result = (wxClipboard *)wxClipboard::Get();
35753 wxPyEndAllowThreads(__tstate);
35754 if (PyErr_Occurred()) SWIG_fail;
35755 }
35756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35757 return resultobj;
35758 fail:
35759 return NULL;
35760 }
35761
35762
35763 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35764 PyObject *obj;
35765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35766 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35767 return SWIG_Py_Void();
35768 }
35769
35770 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35771 return SWIG_Python_InitShadowInstance(args);
35772 }
35773
35774 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35775 PyObject *resultobj = 0;
35776 wxClipboard *arg1 = (wxClipboard *) NULL ;
35777 wxClipboardLocker *result = 0 ;
35778 void *argp1 = 0 ;
35779 int res1 = 0 ;
35780 PyObject * obj0 = 0 ;
35781 char * kwnames[] = {
35782 (char *) "clipboard", NULL
35783 };
35784
35785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35786 if (obj0) {
35787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35788 if (!SWIG_IsOK(res1)) {
35789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35790 }
35791 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35792 }
35793 {
35794 PyThreadState* __tstate = wxPyBeginAllowThreads();
35795 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35796 wxPyEndAllowThreads(__tstate);
35797 if (PyErr_Occurred()) SWIG_fail;
35798 }
35799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35800 return resultobj;
35801 fail:
35802 return NULL;
35803 }
35804
35805
35806 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35807 PyObject *resultobj = 0;
35808 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35809 void *argp1 = 0 ;
35810 int res1 = 0 ;
35811 PyObject *swig_obj[1] ;
35812
35813 if (!args) SWIG_fail;
35814 swig_obj[0] = args;
35815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35816 if (!SWIG_IsOK(res1)) {
35817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35818 }
35819 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35820 {
35821 PyThreadState* __tstate = wxPyBeginAllowThreads();
35822 delete arg1;
35823
35824 wxPyEndAllowThreads(__tstate);
35825 if (PyErr_Occurred()) SWIG_fail;
35826 }
35827 resultobj = SWIG_Py_Void();
35828 return resultobj;
35829 fail:
35830 return NULL;
35831 }
35832
35833
35834 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35835 PyObject *resultobj = 0;
35836 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35837 bool result;
35838 void *argp1 = 0 ;
35839 int res1 = 0 ;
35840 PyObject *swig_obj[1] ;
35841
35842 if (!args) SWIG_fail;
35843 swig_obj[0] = args;
35844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35845 if (!SWIG_IsOK(res1)) {
35846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35847 }
35848 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35849 {
35850 PyThreadState* __tstate = wxPyBeginAllowThreads();
35851 result = (bool)wxClipboardLocker___nonzero__(arg1);
35852 wxPyEndAllowThreads(__tstate);
35853 if (PyErr_Occurred()) SWIG_fail;
35854 }
35855 {
35856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35857 }
35858 return resultobj;
35859 fail:
35860 return NULL;
35861 }
35862
35863
35864 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35865 PyObject *obj;
35866 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35867 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35868 return SWIG_Py_Void();
35869 }
35870
35871 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35872 return SWIG_Python_InitShadowInstance(args);
35873 }
35874
35875 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35876 PyObject *resultobj = 0;
35877 int arg1 = (int) 0 ;
35878 int arg2 = (int) 0 ;
35879 int arg3 = (int) 0 ;
35880 int arg4 = (int) 0 ;
35881 wxVideoMode *result = 0 ;
35882 int val1 ;
35883 int ecode1 = 0 ;
35884 int val2 ;
35885 int ecode2 = 0 ;
35886 int val3 ;
35887 int ecode3 = 0 ;
35888 int val4 ;
35889 int ecode4 = 0 ;
35890 PyObject * obj0 = 0 ;
35891 PyObject * obj1 = 0 ;
35892 PyObject * obj2 = 0 ;
35893 PyObject * obj3 = 0 ;
35894 char * kwnames[] = {
35895 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35896 };
35897
35898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35899 if (obj0) {
35900 ecode1 = SWIG_AsVal_int(obj0, &val1);
35901 if (!SWIG_IsOK(ecode1)) {
35902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35903 }
35904 arg1 = static_cast< int >(val1);
35905 }
35906 if (obj1) {
35907 ecode2 = SWIG_AsVal_int(obj1, &val2);
35908 if (!SWIG_IsOK(ecode2)) {
35909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35910 }
35911 arg2 = static_cast< int >(val2);
35912 }
35913 if (obj2) {
35914 ecode3 = SWIG_AsVal_int(obj2, &val3);
35915 if (!SWIG_IsOK(ecode3)) {
35916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35917 }
35918 arg3 = static_cast< int >(val3);
35919 }
35920 if (obj3) {
35921 ecode4 = SWIG_AsVal_int(obj3, &val4);
35922 if (!SWIG_IsOK(ecode4)) {
35923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35924 }
35925 arg4 = static_cast< int >(val4);
35926 }
35927 {
35928 PyThreadState* __tstate = wxPyBeginAllowThreads();
35929 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35930 wxPyEndAllowThreads(__tstate);
35931 if (PyErr_Occurred()) SWIG_fail;
35932 }
35933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35934 return resultobj;
35935 fail:
35936 return NULL;
35937 }
35938
35939
35940 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35941 PyObject *resultobj = 0;
35942 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35943 void *argp1 = 0 ;
35944 int res1 = 0 ;
35945 PyObject *swig_obj[1] ;
35946
35947 if (!args) SWIG_fail;
35948 swig_obj[0] = args;
35949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35950 if (!SWIG_IsOK(res1)) {
35951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35952 }
35953 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35954 {
35955 PyThreadState* __tstate = wxPyBeginAllowThreads();
35956 delete arg1;
35957
35958 wxPyEndAllowThreads(__tstate);
35959 if (PyErr_Occurred()) SWIG_fail;
35960 }
35961 resultobj = SWIG_Py_Void();
35962 return resultobj;
35963 fail:
35964 return NULL;
35965 }
35966
35967
35968 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35969 PyObject *resultobj = 0;
35970 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35971 wxVideoMode *arg2 = 0 ;
35972 bool result;
35973 void *argp1 = 0 ;
35974 int res1 = 0 ;
35975 void *argp2 = 0 ;
35976 int res2 = 0 ;
35977 PyObject * obj0 = 0 ;
35978 PyObject * obj1 = 0 ;
35979 char * kwnames[] = {
35980 (char *) "self",(char *) "other", NULL
35981 };
35982
35983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35985 if (!SWIG_IsOK(res1)) {
35986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35987 }
35988 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35989 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35990 if (!SWIG_IsOK(res2)) {
35991 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35992 }
35993 if (!argp2) {
35994 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35995 }
35996 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35997 {
35998 PyThreadState* __tstate = wxPyBeginAllowThreads();
35999 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
36000 wxPyEndAllowThreads(__tstate);
36001 if (PyErr_Occurred()) SWIG_fail;
36002 }
36003 {
36004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36005 }
36006 return resultobj;
36007 fail:
36008 return NULL;
36009 }
36010
36011
36012 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36013 PyObject *resultobj = 0;
36014 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36015 int result;
36016 void *argp1 = 0 ;
36017 int res1 = 0 ;
36018 PyObject *swig_obj[1] ;
36019
36020 if (!args) SWIG_fail;
36021 swig_obj[0] = args;
36022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36023 if (!SWIG_IsOK(res1)) {
36024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36025 }
36026 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36027 {
36028 PyThreadState* __tstate = wxPyBeginAllowThreads();
36029 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36030 wxPyEndAllowThreads(__tstate);
36031 if (PyErr_Occurred()) SWIG_fail;
36032 }
36033 resultobj = SWIG_From_int(static_cast< int >(result));
36034 return resultobj;
36035 fail:
36036 return NULL;
36037 }
36038
36039
36040 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36041 PyObject *resultobj = 0;
36042 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36043 int result;
36044 void *argp1 = 0 ;
36045 int res1 = 0 ;
36046 PyObject *swig_obj[1] ;
36047
36048 if (!args) SWIG_fail;
36049 swig_obj[0] = args;
36050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36051 if (!SWIG_IsOK(res1)) {
36052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36053 }
36054 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36055 {
36056 PyThreadState* __tstate = wxPyBeginAllowThreads();
36057 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36058 wxPyEndAllowThreads(__tstate);
36059 if (PyErr_Occurred()) SWIG_fail;
36060 }
36061 resultobj = SWIG_From_int(static_cast< int >(result));
36062 return resultobj;
36063 fail:
36064 return NULL;
36065 }
36066
36067
36068 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36069 PyObject *resultobj = 0;
36070 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36071 int result;
36072 void *argp1 = 0 ;
36073 int res1 = 0 ;
36074 PyObject *swig_obj[1] ;
36075
36076 if (!args) SWIG_fail;
36077 swig_obj[0] = args;
36078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36079 if (!SWIG_IsOK(res1)) {
36080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36081 }
36082 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36083 {
36084 PyThreadState* __tstate = wxPyBeginAllowThreads();
36085 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36086 wxPyEndAllowThreads(__tstate);
36087 if (PyErr_Occurred()) SWIG_fail;
36088 }
36089 resultobj = SWIG_From_int(static_cast< int >(result));
36090 return resultobj;
36091 fail:
36092 return NULL;
36093 }
36094
36095
36096 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36097 PyObject *resultobj = 0;
36098 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36099 bool result;
36100 void *argp1 = 0 ;
36101 int res1 = 0 ;
36102 PyObject *swig_obj[1] ;
36103
36104 if (!args) SWIG_fail;
36105 swig_obj[0] = args;
36106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36107 if (!SWIG_IsOK(res1)) {
36108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36109 }
36110 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36111 {
36112 PyThreadState* __tstate = wxPyBeginAllowThreads();
36113 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36114 wxPyEndAllowThreads(__tstate);
36115 if (PyErr_Occurred()) SWIG_fail;
36116 }
36117 {
36118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36119 }
36120 return resultobj;
36121 fail:
36122 return NULL;
36123 }
36124
36125
36126 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36127 PyObject *resultobj = 0;
36128 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36129 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36130 bool result;
36131 void *argp1 = 0 ;
36132 int res1 = 0 ;
36133 void *argp2 = 0 ;
36134 int res2 = 0 ;
36135 PyObject * obj0 = 0 ;
36136 PyObject * obj1 = 0 ;
36137 char * kwnames[] = {
36138 (char *) "self",(char *) "other", NULL
36139 };
36140
36141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36143 if (!SWIG_IsOK(res1)) {
36144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36145 }
36146 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36148 if (!SWIG_IsOK(res2)) {
36149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36150 }
36151 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36152 {
36153 PyThreadState* __tstate = wxPyBeginAllowThreads();
36154 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36155 wxPyEndAllowThreads(__tstate);
36156 if (PyErr_Occurred()) SWIG_fail;
36157 }
36158 {
36159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36160 }
36161 return resultobj;
36162 fail:
36163 return NULL;
36164 }
36165
36166
36167 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36168 PyObject *resultobj = 0;
36169 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36170 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36171 bool result;
36172 void *argp1 = 0 ;
36173 int res1 = 0 ;
36174 void *argp2 = 0 ;
36175 int res2 = 0 ;
36176 PyObject * obj0 = 0 ;
36177 PyObject * obj1 = 0 ;
36178 char * kwnames[] = {
36179 (char *) "self",(char *) "other", NULL
36180 };
36181
36182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36184 if (!SWIG_IsOK(res1)) {
36185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36186 }
36187 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36188 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36189 if (!SWIG_IsOK(res2)) {
36190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36191 }
36192 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36193 {
36194 PyThreadState* __tstate = wxPyBeginAllowThreads();
36195 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36196 wxPyEndAllowThreads(__tstate);
36197 if (PyErr_Occurred()) SWIG_fail;
36198 }
36199 {
36200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36201 }
36202 return resultobj;
36203 fail:
36204 return NULL;
36205 }
36206
36207
36208 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36209 PyObject *resultobj = 0;
36210 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36211 int arg2 ;
36212 void *argp1 = 0 ;
36213 int res1 = 0 ;
36214 int val2 ;
36215 int ecode2 = 0 ;
36216 PyObject *swig_obj[2] ;
36217
36218 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36220 if (!SWIG_IsOK(res1)) {
36221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36222 }
36223 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36224 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36225 if (!SWIG_IsOK(ecode2)) {
36226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36227 }
36228 arg2 = static_cast< int >(val2);
36229 if (arg1) (arg1)->w = arg2;
36230
36231 resultobj = SWIG_Py_Void();
36232 return resultobj;
36233 fail:
36234 return NULL;
36235 }
36236
36237
36238 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36239 PyObject *resultobj = 0;
36240 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36241 int result;
36242 void *argp1 = 0 ;
36243 int res1 = 0 ;
36244 PyObject *swig_obj[1] ;
36245
36246 if (!args) SWIG_fail;
36247 swig_obj[0] = args;
36248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36249 if (!SWIG_IsOK(res1)) {
36250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36251 }
36252 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36253 result = (int) ((arg1)->w);
36254 resultobj = SWIG_From_int(static_cast< int >(result));
36255 return resultobj;
36256 fail:
36257 return NULL;
36258 }
36259
36260
36261 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36262 PyObject *resultobj = 0;
36263 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36264 int arg2 ;
36265 void *argp1 = 0 ;
36266 int res1 = 0 ;
36267 int val2 ;
36268 int ecode2 = 0 ;
36269 PyObject *swig_obj[2] ;
36270
36271 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36273 if (!SWIG_IsOK(res1)) {
36274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36275 }
36276 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36277 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36278 if (!SWIG_IsOK(ecode2)) {
36279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36280 }
36281 arg2 = static_cast< int >(val2);
36282 if (arg1) (arg1)->h = arg2;
36283
36284 resultobj = SWIG_Py_Void();
36285 return resultobj;
36286 fail:
36287 return NULL;
36288 }
36289
36290
36291 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36292 PyObject *resultobj = 0;
36293 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36294 int result;
36295 void *argp1 = 0 ;
36296 int res1 = 0 ;
36297 PyObject *swig_obj[1] ;
36298
36299 if (!args) SWIG_fail;
36300 swig_obj[0] = args;
36301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36302 if (!SWIG_IsOK(res1)) {
36303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36304 }
36305 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36306 result = (int) ((arg1)->h);
36307 resultobj = SWIG_From_int(static_cast< int >(result));
36308 return resultobj;
36309 fail:
36310 return NULL;
36311 }
36312
36313
36314 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36315 PyObject *resultobj = 0;
36316 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36317 int arg2 ;
36318 void *argp1 = 0 ;
36319 int res1 = 0 ;
36320 int val2 ;
36321 int ecode2 = 0 ;
36322 PyObject *swig_obj[2] ;
36323
36324 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36326 if (!SWIG_IsOK(res1)) {
36327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36328 }
36329 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36330 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36331 if (!SWIG_IsOK(ecode2)) {
36332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36333 }
36334 arg2 = static_cast< int >(val2);
36335 if (arg1) (arg1)->bpp = arg2;
36336
36337 resultobj = SWIG_Py_Void();
36338 return resultobj;
36339 fail:
36340 return NULL;
36341 }
36342
36343
36344 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36345 PyObject *resultobj = 0;
36346 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36347 int result;
36348 void *argp1 = 0 ;
36349 int res1 = 0 ;
36350 PyObject *swig_obj[1] ;
36351
36352 if (!args) SWIG_fail;
36353 swig_obj[0] = args;
36354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36355 if (!SWIG_IsOK(res1)) {
36356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36357 }
36358 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36359 result = (int) ((arg1)->bpp);
36360 resultobj = SWIG_From_int(static_cast< int >(result));
36361 return resultobj;
36362 fail:
36363 return NULL;
36364 }
36365
36366
36367 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36368 PyObject *resultobj = 0;
36369 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36370 int arg2 ;
36371 void *argp1 = 0 ;
36372 int res1 = 0 ;
36373 int val2 ;
36374 int ecode2 = 0 ;
36375 PyObject *swig_obj[2] ;
36376
36377 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36379 if (!SWIG_IsOK(res1)) {
36380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36381 }
36382 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36383 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36384 if (!SWIG_IsOK(ecode2)) {
36385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36386 }
36387 arg2 = static_cast< int >(val2);
36388 if (arg1) (arg1)->refresh = arg2;
36389
36390 resultobj = SWIG_Py_Void();
36391 return resultobj;
36392 fail:
36393 return NULL;
36394 }
36395
36396
36397 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36398 PyObject *resultobj = 0;
36399 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36400 int result;
36401 void *argp1 = 0 ;
36402 int res1 = 0 ;
36403 PyObject *swig_obj[1] ;
36404
36405 if (!args) SWIG_fail;
36406 swig_obj[0] = args;
36407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36408 if (!SWIG_IsOK(res1)) {
36409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36410 }
36411 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36412 result = (int) ((arg1)->refresh);
36413 resultobj = SWIG_From_int(static_cast< int >(result));
36414 return resultobj;
36415 fail:
36416 return NULL;
36417 }
36418
36419
36420 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36421 PyObject *obj;
36422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36423 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36424 return SWIG_Py_Void();
36425 }
36426
36427 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36428 return SWIG_Python_InitShadowInstance(args);
36429 }
36430
36431 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36432 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36433 return 1;
36434 }
36435
36436
36437 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36438 PyObject *pyobj = 0;
36439
36440 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36441 return pyobj;
36442 }
36443
36444
36445 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36446 PyObject *resultobj = 0;
36447 unsigned int arg1 = (unsigned int) 0 ;
36448 wxDisplay *result = 0 ;
36449 unsigned int val1 ;
36450 int ecode1 = 0 ;
36451 PyObject * obj0 = 0 ;
36452 char * kwnames[] = {
36453 (char *) "index", NULL
36454 };
36455
36456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36457 if (obj0) {
36458 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36459 if (!SWIG_IsOK(ecode1)) {
36460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36461 }
36462 arg1 = static_cast< unsigned int >(val1);
36463 }
36464 {
36465 PyThreadState* __tstate = wxPyBeginAllowThreads();
36466 result = (wxDisplay *)new wxDisplay(arg1);
36467 wxPyEndAllowThreads(__tstate);
36468 if (PyErr_Occurred()) SWIG_fail;
36469 }
36470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36471 return resultobj;
36472 fail:
36473 return NULL;
36474 }
36475
36476
36477 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36478 PyObject *resultobj = 0;
36479 wxDisplay *arg1 = (wxDisplay *) 0 ;
36480 void *argp1 = 0 ;
36481 int res1 = 0 ;
36482 PyObject *swig_obj[1] ;
36483
36484 if (!args) SWIG_fail;
36485 swig_obj[0] = args;
36486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36487 if (!SWIG_IsOK(res1)) {
36488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36489 }
36490 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36491 {
36492 PyThreadState* __tstate = wxPyBeginAllowThreads();
36493 delete arg1;
36494
36495 wxPyEndAllowThreads(__tstate);
36496 if (PyErr_Occurred()) SWIG_fail;
36497 }
36498 resultobj = SWIG_Py_Void();
36499 return resultobj;
36500 fail:
36501 return NULL;
36502 }
36503
36504
36505 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36506 PyObject *resultobj = 0;
36507 unsigned int result;
36508
36509 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36510 {
36511 PyThreadState* __tstate = wxPyBeginAllowThreads();
36512 result = (unsigned int)wxDisplay::GetCount();
36513 wxPyEndAllowThreads(__tstate);
36514 if (PyErr_Occurred()) SWIG_fail;
36515 }
36516 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36517 return resultobj;
36518 fail:
36519 return NULL;
36520 }
36521
36522
36523 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36524 PyObject *resultobj = 0;
36525 wxPoint *arg1 = 0 ;
36526 int result;
36527 wxPoint temp1 ;
36528 PyObject * obj0 = 0 ;
36529 char * kwnames[] = {
36530 (char *) "pt", NULL
36531 };
36532
36533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36534 {
36535 arg1 = &temp1;
36536 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36537 }
36538 {
36539 PyThreadState* __tstate = wxPyBeginAllowThreads();
36540 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36541 wxPyEndAllowThreads(__tstate);
36542 if (PyErr_Occurred()) SWIG_fail;
36543 }
36544 resultobj = SWIG_From_int(static_cast< int >(result));
36545 return resultobj;
36546 fail:
36547 return NULL;
36548 }
36549
36550
36551 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36552 PyObject *resultobj = 0;
36553 wxWindow *arg1 = (wxWindow *) 0 ;
36554 int result;
36555 void *argp1 = 0 ;
36556 int res1 = 0 ;
36557 PyObject * obj0 = 0 ;
36558 char * kwnames[] = {
36559 (char *) "window", NULL
36560 };
36561
36562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36564 if (!SWIG_IsOK(res1)) {
36565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow const *""'");
36566 }
36567 arg1 = reinterpret_cast< wxWindow * >(argp1);
36568 {
36569 PyThreadState* __tstate = wxPyBeginAllowThreads();
36570 result = (int)wxDisplay::GetFromWindow((wxWindow const *)arg1);
36571 wxPyEndAllowThreads(__tstate);
36572 if (PyErr_Occurred()) SWIG_fail;
36573 }
36574 resultobj = SWIG_From_int(static_cast< int >(result));
36575 return resultobj;
36576 fail:
36577 return NULL;
36578 }
36579
36580
36581 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36582 PyObject *resultobj = 0;
36583 wxDisplay *arg1 = (wxDisplay *) 0 ;
36584 bool result;
36585 void *argp1 = 0 ;
36586 int res1 = 0 ;
36587 PyObject *swig_obj[1] ;
36588
36589 if (!args) SWIG_fail;
36590 swig_obj[0] = args;
36591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36592 if (!SWIG_IsOK(res1)) {
36593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36594 }
36595 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36596 {
36597 PyThreadState* __tstate = wxPyBeginAllowThreads();
36598 result = (bool)((wxDisplay const *)arg1)->IsOk();
36599 wxPyEndAllowThreads(__tstate);
36600 if (PyErr_Occurred()) SWIG_fail;
36601 }
36602 {
36603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36604 }
36605 return resultobj;
36606 fail:
36607 return NULL;
36608 }
36609
36610
36611 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36612 PyObject *resultobj = 0;
36613 wxDisplay *arg1 = (wxDisplay *) 0 ;
36614 wxRect result;
36615 void *argp1 = 0 ;
36616 int res1 = 0 ;
36617 PyObject *swig_obj[1] ;
36618
36619 if (!args) SWIG_fail;
36620 swig_obj[0] = args;
36621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36622 if (!SWIG_IsOK(res1)) {
36623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36624 }
36625 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36626 {
36627 PyThreadState* __tstate = wxPyBeginAllowThreads();
36628 result = ((wxDisplay const *)arg1)->GetGeometry();
36629 wxPyEndAllowThreads(__tstate);
36630 if (PyErr_Occurred()) SWIG_fail;
36631 }
36632 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36633 return resultobj;
36634 fail:
36635 return NULL;
36636 }
36637
36638
36639 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36640 PyObject *resultobj = 0;
36641 wxDisplay *arg1 = (wxDisplay *) 0 ;
36642 wxRect result;
36643 void *argp1 = 0 ;
36644 int res1 = 0 ;
36645 PyObject *swig_obj[1] ;
36646
36647 if (!args) SWIG_fail;
36648 swig_obj[0] = args;
36649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36650 if (!SWIG_IsOK(res1)) {
36651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36652 }
36653 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36654 {
36655 PyThreadState* __tstate = wxPyBeginAllowThreads();
36656 result = ((wxDisplay const *)arg1)->GetClientArea();
36657 wxPyEndAllowThreads(__tstate);
36658 if (PyErr_Occurred()) SWIG_fail;
36659 }
36660 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36661 return resultobj;
36662 fail:
36663 return NULL;
36664 }
36665
36666
36667 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36668 PyObject *resultobj = 0;
36669 wxDisplay *arg1 = (wxDisplay *) 0 ;
36670 wxString result;
36671 void *argp1 = 0 ;
36672 int res1 = 0 ;
36673 PyObject *swig_obj[1] ;
36674
36675 if (!args) SWIG_fail;
36676 swig_obj[0] = args;
36677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36678 if (!SWIG_IsOK(res1)) {
36679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36680 }
36681 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36682 {
36683 PyThreadState* __tstate = wxPyBeginAllowThreads();
36684 result = ((wxDisplay const *)arg1)->GetName();
36685 wxPyEndAllowThreads(__tstate);
36686 if (PyErr_Occurred()) SWIG_fail;
36687 }
36688 {
36689 #if wxUSE_UNICODE
36690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36691 #else
36692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36693 #endif
36694 }
36695 return resultobj;
36696 fail:
36697 return NULL;
36698 }
36699
36700
36701 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36702 PyObject *resultobj = 0;
36703 wxDisplay *arg1 = (wxDisplay *) 0 ;
36704 bool result;
36705 void *argp1 = 0 ;
36706 int res1 = 0 ;
36707 PyObject *swig_obj[1] ;
36708
36709 if (!args) SWIG_fail;
36710 swig_obj[0] = args;
36711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36712 if (!SWIG_IsOK(res1)) {
36713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36714 }
36715 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36716 {
36717 PyThreadState* __tstate = wxPyBeginAllowThreads();
36718 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36719 wxPyEndAllowThreads(__tstate);
36720 if (PyErr_Occurred()) SWIG_fail;
36721 }
36722 {
36723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36724 }
36725 return resultobj;
36726 fail:
36727 return NULL;
36728 }
36729
36730
36731 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36732 PyObject *resultobj = 0;
36733 wxDisplay *arg1 = (wxDisplay *) 0 ;
36734 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36735 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36736 PyObject *result = 0 ;
36737 void *argp1 = 0 ;
36738 int res1 = 0 ;
36739 void *argp2 = 0 ;
36740 int res2 = 0 ;
36741 PyObject * obj0 = 0 ;
36742 PyObject * obj1 = 0 ;
36743 char * kwnames[] = {
36744 (char *) "self",(char *) "mode", NULL
36745 };
36746
36747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36749 if (!SWIG_IsOK(res1)) {
36750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36751 }
36752 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36753 if (obj1) {
36754 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36755 if (!SWIG_IsOK(res2)) {
36756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36757 }
36758 if (!argp2) {
36759 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36760 }
36761 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36762 }
36763 {
36764 PyThreadState* __tstate = wxPyBeginAllowThreads();
36765 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36766 wxPyEndAllowThreads(__tstate);
36767 if (PyErr_Occurred()) SWIG_fail;
36768 }
36769 resultobj = result;
36770 return resultobj;
36771 fail:
36772 return NULL;
36773 }
36774
36775
36776 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36777 PyObject *resultobj = 0;
36778 wxDisplay *arg1 = (wxDisplay *) 0 ;
36779 wxVideoMode result;
36780 void *argp1 = 0 ;
36781 int res1 = 0 ;
36782 PyObject *swig_obj[1] ;
36783
36784 if (!args) SWIG_fail;
36785 swig_obj[0] = args;
36786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36787 if (!SWIG_IsOK(res1)) {
36788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36789 }
36790 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36791 {
36792 PyThreadState* __tstate = wxPyBeginAllowThreads();
36793 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36794 wxPyEndAllowThreads(__tstate);
36795 if (PyErr_Occurred()) SWIG_fail;
36796 }
36797 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36798 return resultobj;
36799 fail:
36800 return NULL;
36801 }
36802
36803
36804 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36805 PyObject *resultobj = 0;
36806 wxDisplay *arg1 = (wxDisplay *) 0 ;
36807 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36808 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36809 bool result;
36810 void *argp1 = 0 ;
36811 int res1 = 0 ;
36812 void *argp2 = 0 ;
36813 int res2 = 0 ;
36814 PyObject * obj0 = 0 ;
36815 PyObject * obj1 = 0 ;
36816 char * kwnames[] = {
36817 (char *) "self",(char *) "mode", NULL
36818 };
36819
36820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36822 if (!SWIG_IsOK(res1)) {
36823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36824 }
36825 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36826 if (obj1) {
36827 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36828 if (!SWIG_IsOK(res2)) {
36829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36830 }
36831 if (!argp2) {
36832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36833 }
36834 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36835 }
36836 {
36837 PyThreadState* __tstate = wxPyBeginAllowThreads();
36838 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36839 wxPyEndAllowThreads(__tstate);
36840 if (PyErr_Occurred()) SWIG_fail;
36841 }
36842 {
36843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36844 }
36845 return resultobj;
36846 fail:
36847 return NULL;
36848 }
36849
36850
36851 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36852 PyObject *resultobj = 0;
36853 wxDisplay *arg1 = (wxDisplay *) 0 ;
36854 void *argp1 = 0 ;
36855 int res1 = 0 ;
36856 PyObject *swig_obj[1] ;
36857
36858 if (!args) SWIG_fail;
36859 swig_obj[0] = args;
36860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36861 if (!SWIG_IsOK(res1)) {
36862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36863 }
36864 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36865 {
36866 PyThreadState* __tstate = wxPyBeginAllowThreads();
36867 wxDisplay_ResetMode(arg1);
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 resultobj = SWIG_Py_Void();
36872 return resultobj;
36873 fail:
36874 return NULL;
36875 }
36876
36877
36878 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36879 PyObject *obj;
36880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36881 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36882 return SWIG_Py_Void();
36883 }
36884
36885 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36886 return SWIG_Python_InitShadowInstance(args);
36887 }
36888
36889 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36890 PyObject *resultobj = 0;
36891 wxStandardPaths *result = 0 ;
36892
36893 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36894 {
36895 PyThreadState* __tstate = wxPyBeginAllowThreads();
36896 result = (wxStandardPaths *)wxStandardPaths_Get();
36897 wxPyEndAllowThreads(__tstate);
36898 if (PyErr_Occurred()) SWIG_fail;
36899 }
36900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36901 return resultobj;
36902 fail:
36903 return NULL;
36904 }
36905
36906
36907 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36908 PyObject *resultobj = 0;
36909 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36910 wxString result;
36911 void *argp1 = 0 ;
36912 int res1 = 0 ;
36913 PyObject *swig_obj[1] ;
36914
36915 if (!args) SWIG_fail;
36916 swig_obj[0] = args;
36917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36918 if (!SWIG_IsOK(res1)) {
36919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36920 }
36921 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36922 {
36923 PyThreadState* __tstate = wxPyBeginAllowThreads();
36924 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36925 wxPyEndAllowThreads(__tstate);
36926 if (PyErr_Occurred()) SWIG_fail;
36927 }
36928 {
36929 #if wxUSE_UNICODE
36930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36931 #else
36932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36933 #endif
36934 }
36935 return resultobj;
36936 fail:
36937 return NULL;
36938 }
36939
36940
36941 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36942 PyObject *resultobj = 0;
36943 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36944 wxString result;
36945 void *argp1 = 0 ;
36946 int res1 = 0 ;
36947 PyObject *swig_obj[1] ;
36948
36949 if (!args) SWIG_fail;
36950 swig_obj[0] = args;
36951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36952 if (!SWIG_IsOK(res1)) {
36953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36954 }
36955 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36956 {
36957 PyThreadState* __tstate = wxPyBeginAllowThreads();
36958 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36959 wxPyEndAllowThreads(__tstate);
36960 if (PyErr_Occurred()) SWIG_fail;
36961 }
36962 {
36963 #if wxUSE_UNICODE
36964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36965 #else
36966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36967 #endif
36968 }
36969 return resultobj;
36970 fail:
36971 return NULL;
36972 }
36973
36974
36975 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36976 PyObject *resultobj = 0;
36977 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36978 wxString result;
36979 void *argp1 = 0 ;
36980 int res1 = 0 ;
36981 PyObject *swig_obj[1] ;
36982
36983 if (!args) SWIG_fail;
36984 swig_obj[0] = args;
36985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36986 if (!SWIG_IsOK(res1)) {
36987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36988 }
36989 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36990 {
36991 PyThreadState* __tstate = wxPyBeginAllowThreads();
36992 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36993 wxPyEndAllowThreads(__tstate);
36994 if (PyErr_Occurred()) SWIG_fail;
36995 }
36996 {
36997 #if wxUSE_UNICODE
36998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36999 #else
37000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37001 #endif
37002 }
37003 return resultobj;
37004 fail:
37005 return NULL;
37006 }
37007
37008
37009 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37010 PyObject *resultobj = 0;
37011 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37012 wxString result;
37013 void *argp1 = 0 ;
37014 int res1 = 0 ;
37015 PyObject *swig_obj[1] ;
37016
37017 if (!args) SWIG_fail;
37018 swig_obj[0] = args;
37019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37020 if (!SWIG_IsOK(res1)) {
37021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37022 }
37023 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37024 {
37025 PyThreadState* __tstate = wxPyBeginAllowThreads();
37026 result = ((wxStandardPaths const *)arg1)->GetDataDir();
37027 wxPyEndAllowThreads(__tstate);
37028 if (PyErr_Occurred()) SWIG_fail;
37029 }
37030 {
37031 #if wxUSE_UNICODE
37032 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37033 #else
37034 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37035 #endif
37036 }
37037 return resultobj;
37038 fail:
37039 return NULL;
37040 }
37041
37042
37043 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37044 PyObject *resultobj = 0;
37045 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37046 wxString result;
37047 void *argp1 = 0 ;
37048 int res1 = 0 ;
37049 PyObject *swig_obj[1] ;
37050
37051 if (!args) SWIG_fail;
37052 swig_obj[0] = args;
37053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37054 if (!SWIG_IsOK(res1)) {
37055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37056 }
37057 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37058 {
37059 PyThreadState* __tstate = wxPyBeginAllowThreads();
37060 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37061 wxPyEndAllowThreads(__tstate);
37062 if (PyErr_Occurred()) SWIG_fail;
37063 }
37064 {
37065 #if wxUSE_UNICODE
37066 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37067 #else
37068 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37069 #endif
37070 }
37071 return resultobj;
37072 fail:
37073 return NULL;
37074 }
37075
37076
37077 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37078 PyObject *resultobj = 0;
37079 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37080 wxString result;
37081 void *argp1 = 0 ;
37082 int res1 = 0 ;
37083 PyObject *swig_obj[1] ;
37084
37085 if (!args) SWIG_fail;
37086 swig_obj[0] = args;
37087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37088 if (!SWIG_IsOK(res1)) {
37089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37090 }
37091 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37092 {
37093 PyThreadState* __tstate = wxPyBeginAllowThreads();
37094 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37095 wxPyEndAllowThreads(__tstate);
37096 if (PyErr_Occurred()) SWIG_fail;
37097 }
37098 {
37099 #if wxUSE_UNICODE
37100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37101 #else
37102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37103 #endif
37104 }
37105 return resultobj;
37106 fail:
37107 return NULL;
37108 }
37109
37110
37111 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37112 PyObject *resultobj = 0;
37113 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37114 wxString result;
37115 void *argp1 = 0 ;
37116 int res1 = 0 ;
37117 PyObject *swig_obj[1] ;
37118
37119 if (!args) SWIG_fail;
37120 swig_obj[0] = args;
37121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37122 if (!SWIG_IsOK(res1)) {
37123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37124 }
37125 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37126 {
37127 PyThreadState* __tstate = wxPyBeginAllowThreads();
37128 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37129 wxPyEndAllowThreads(__tstate);
37130 if (PyErr_Occurred()) SWIG_fail;
37131 }
37132 {
37133 #if wxUSE_UNICODE
37134 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37135 #else
37136 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37137 #endif
37138 }
37139 return resultobj;
37140 fail:
37141 return NULL;
37142 }
37143
37144
37145 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37146 PyObject *resultobj = 0;
37147 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37148 wxString result;
37149 void *argp1 = 0 ;
37150 int res1 = 0 ;
37151 PyObject *swig_obj[1] ;
37152
37153 if (!args) SWIG_fail;
37154 swig_obj[0] = args;
37155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37156 if (!SWIG_IsOK(res1)) {
37157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37158 }
37159 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37163 wxPyEndAllowThreads(__tstate);
37164 if (PyErr_Occurred()) SWIG_fail;
37165 }
37166 {
37167 #if wxUSE_UNICODE
37168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37169 #else
37170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37171 #endif
37172 }
37173 return resultobj;
37174 fail:
37175 return NULL;
37176 }
37177
37178
37179 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37180 PyObject *resultobj = 0;
37181 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37182 wxString result;
37183 void *argp1 = 0 ;
37184 int res1 = 0 ;
37185 PyObject *swig_obj[1] ;
37186
37187 if (!args) SWIG_fail;
37188 swig_obj[0] = args;
37189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37190 if (!SWIG_IsOK(res1)) {
37191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37192 }
37193 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37194 {
37195 PyThreadState* __tstate = wxPyBeginAllowThreads();
37196 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37197 wxPyEndAllowThreads(__tstate);
37198 if (PyErr_Occurred()) SWIG_fail;
37199 }
37200 {
37201 #if wxUSE_UNICODE
37202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37203 #else
37204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37205 #endif
37206 }
37207 return resultobj;
37208 fail:
37209 return NULL;
37210 }
37211
37212
37213 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37214 PyObject *resultobj = 0;
37215 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37216 wxString *arg2 = 0 ;
37217 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37218 wxString result;
37219 void *argp1 = 0 ;
37220 int res1 = 0 ;
37221 bool temp2 = false ;
37222 int val3 ;
37223 int ecode3 = 0 ;
37224 PyObject * obj0 = 0 ;
37225 PyObject * obj1 = 0 ;
37226 PyObject * obj2 = 0 ;
37227 char * kwnames[] = {
37228 (char *) "self",(char *) "lang",(char *) "category", NULL
37229 };
37230
37231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37233 if (!SWIG_IsOK(res1)) {
37234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37235 }
37236 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37237 {
37238 arg2 = wxString_in_helper(obj1);
37239 if (arg2 == NULL) SWIG_fail;
37240 temp2 = true;
37241 }
37242 if (obj2) {
37243 ecode3 = SWIG_AsVal_int(obj2, &val3);
37244 if (!SWIG_IsOK(ecode3)) {
37245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37246 }
37247 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37248 }
37249 {
37250 PyThreadState* __tstate = wxPyBeginAllowThreads();
37251 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37252 wxPyEndAllowThreads(__tstate);
37253 if (PyErr_Occurred()) SWIG_fail;
37254 }
37255 {
37256 #if wxUSE_UNICODE
37257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37258 #else
37259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37260 #endif
37261 }
37262 {
37263 if (temp2)
37264 delete arg2;
37265 }
37266 return resultobj;
37267 fail:
37268 {
37269 if (temp2)
37270 delete arg2;
37271 }
37272 return NULL;
37273 }
37274
37275
37276 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37277 PyObject *resultobj = 0;
37278 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37279 wxString result;
37280 void *argp1 = 0 ;
37281 int res1 = 0 ;
37282 PyObject *swig_obj[1] ;
37283
37284 if (!args) SWIG_fail;
37285 swig_obj[0] = args;
37286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37287 if (!SWIG_IsOK(res1)) {
37288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37289 }
37290 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37291 {
37292 PyThreadState* __tstate = wxPyBeginAllowThreads();
37293 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37294 wxPyEndAllowThreads(__tstate);
37295 if (PyErr_Occurred()) SWIG_fail;
37296 }
37297 {
37298 #if wxUSE_UNICODE
37299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37300 #else
37301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37302 #endif
37303 }
37304 return resultobj;
37305 fail:
37306 return NULL;
37307 }
37308
37309
37310 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37311 PyObject *resultobj = 0;
37312 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37313 wxString result;
37314 void *argp1 = 0 ;
37315 int res1 = 0 ;
37316 PyObject *swig_obj[1] ;
37317
37318 if (!args) SWIG_fail;
37319 swig_obj[0] = args;
37320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37321 if (!SWIG_IsOK(res1)) {
37322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37323 }
37324 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37325 {
37326 PyThreadState* __tstate = wxPyBeginAllowThreads();
37327 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37328 wxPyEndAllowThreads(__tstate);
37329 if (PyErr_Occurred()) SWIG_fail;
37330 }
37331 {
37332 #if wxUSE_UNICODE
37333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37334 #else
37335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37336 #endif
37337 }
37338 return resultobj;
37339 fail:
37340 return NULL;
37341 }
37342
37343
37344 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37345 PyObject *resultobj = 0;
37346 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37347 wxString *arg2 = 0 ;
37348 void *argp1 = 0 ;
37349 int res1 = 0 ;
37350 bool temp2 = false ;
37351 PyObject * obj0 = 0 ;
37352 PyObject * obj1 = 0 ;
37353 char * kwnames[] = {
37354 (char *) "self",(char *) "prefix", NULL
37355 };
37356
37357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37359 if (!SWIG_IsOK(res1)) {
37360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37361 }
37362 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37363 {
37364 arg2 = wxString_in_helper(obj1);
37365 if (arg2 == NULL) SWIG_fail;
37366 temp2 = true;
37367 }
37368 {
37369 PyThreadState* __tstate = wxPyBeginAllowThreads();
37370 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37371 wxPyEndAllowThreads(__tstate);
37372 if (PyErr_Occurred()) SWIG_fail;
37373 }
37374 resultobj = SWIG_Py_Void();
37375 {
37376 if (temp2)
37377 delete arg2;
37378 }
37379 return resultobj;
37380 fail:
37381 {
37382 if (temp2)
37383 delete arg2;
37384 }
37385 return NULL;
37386 }
37387
37388
37389 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37390 PyObject *resultobj = 0;
37391 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37392 wxString result;
37393 void *argp1 = 0 ;
37394 int res1 = 0 ;
37395 PyObject *swig_obj[1] ;
37396
37397 if (!args) SWIG_fail;
37398 swig_obj[0] = args;
37399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37400 if (!SWIG_IsOK(res1)) {
37401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37402 }
37403 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37404 {
37405 PyThreadState* __tstate = wxPyBeginAllowThreads();
37406 result = wxStandardPaths_GetInstallPrefix(arg1);
37407 wxPyEndAllowThreads(__tstate);
37408 if (PyErr_Occurred()) SWIG_fail;
37409 }
37410 {
37411 #if wxUSE_UNICODE
37412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37413 #else
37414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37415 #endif
37416 }
37417 return resultobj;
37418 fail:
37419 return NULL;
37420 }
37421
37422
37423 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37424 PyObject *obj;
37425 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37426 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37427 return SWIG_Py_Void();
37428 }
37429
37430 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37431 PyObject *resultobj = 0;
37432 wxEventType arg1 ;
37433 wxPowerEvent *result = 0 ;
37434 int val1 ;
37435 int ecode1 = 0 ;
37436 PyObject * obj0 = 0 ;
37437 char * kwnames[] = {
37438 (char *) "evtType", NULL
37439 };
37440
37441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37442 ecode1 = SWIG_AsVal_int(obj0, &val1);
37443 if (!SWIG_IsOK(ecode1)) {
37444 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37445 }
37446 arg1 = static_cast< wxEventType >(val1);
37447 {
37448 PyThreadState* __tstate = wxPyBeginAllowThreads();
37449 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37450 wxPyEndAllowThreads(__tstate);
37451 if (PyErr_Occurred()) SWIG_fail;
37452 }
37453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37454 return resultobj;
37455 fail:
37456 return NULL;
37457 }
37458
37459
37460 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37461 PyObject *resultobj = 0;
37462 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37463 void *argp1 = 0 ;
37464 int res1 = 0 ;
37465 PyObject *swig_obj[1] ;
37466
37467 if (!args) SWIG_fail;
37468 swig_obj[0] = args;
37469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37470 if (!SWIG_IsOK(res1)) {
37471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37472 }
37473 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37474 {
37475 PyThreadState* __tstate = wxPyBeginAllowThreads();
37476 (arg1)->Veto();
37477 wxPyEndAllowThreads(__tstate);
37478 if (PyErr_Occurred()) SWIG_fail;
37479 }
37480 resultobj = SWIG_Py_Void();
37481 return resultobj;
37482 fail:
37483 return NULL;
37484 }
37485
37486
37487 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37488 PyObject *resultobj = 0;
37489 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37490 bool result;
37491 void *argp1 = 0 ;
37492 int res1 = 0 ;
37493 PyObject *swig_obj[1] ;
37494
37495 if (!args) SWIG_fail;
37496 swig_obj[0] = args;
37497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37498 if (!SWIG_IsOK(res1)) {
37499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37500 }
37501 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37502 {
37503 PyThreadState* __tstate = wxPyBeginAllowThreads();
37504 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37505 wxPyEndAllowThreads(__tstate);
37506 if (PyErr_Occurred()) SWIG_fail;
37507 }
37508 {
37509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37510 }
37511 return resultobj;
37512 fail:
37513 return NULL;
37514 }
37515
37516
37517 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37518 PyObject *obj;
37519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37520 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37521 return SWIG_Py_Void();
37522 }
37523
37524 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37525 return SWIG_Python_InitShadowInstance(args);
37526 }
37527
37528 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37529 PyObject *resultobj = 0;
37530 wxPowerType result;
37531
37532 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37533 {
37534 PyThreadState* __tstate = wxPyBeginAllowThreads();
37535 result = (wxPowerType)wxGetPowerType();
37536 wxPyEndAllowThreads(__tstate);
37537 if (PyErr_Occurred()) SWIG_fail;
37538 }
37539 resultobj = SWIG_From_int(static_cast< int >(result));
37540 return resultobj;
37541 fail:
37542 return NULL;
37543 }
37544
37545
37546 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37547 PyObject *resultobj = 0;
37548 wxBatteryState result;
37549
37550 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37551 {
37552 PyThreadState* __tstate = wxPyBeginAllowThreads();
37553 result = (wxBatteryState)wxGetBatteryState();
37554 wxPyEndAllowThreads(__tstate);
37555 if (PyErr_Occurred()) SWIG_fail;
37556 }
37557 resultobj = SWIG_From_int(static_cast< int >(result));
37558 return resultobj;
37559 fail:
37560 return NULL;
37561 }
37562
37563
37564 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37565 PyObject *resultobj = 0;
37566 wxAboutDialogInfo *result = 0 ;
37567
37568 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37569 {
37570 PyThreadState* __tstate = wxPyBeginAllowThreads();
37571 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37572 wxPyEndAllowThreads(__tstate);
37573 if (PyErr_Occurred()) SWIG_fail;
37574 }
37575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37576 return resultobj;
37577 fail:
37578 return NULL;
37579 }
37580
37581
37582 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37583 PyObject *resultobj = 0;
37584 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37585 void *argp1 = 0 ;
37586 int res1 = 0 ;
37587 PyObject *swig_obj[1] ;
37588
37589 if (!args) SWIG_fail;
37590 swig_obj[0] = args;
37591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37592 if (!SWIG_IsOK(res1)) {
37593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37594 }
37595 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37596 {
37597 PyThreadState* __tstate = wxPyBeginAllowThreads();
37598 delete arg1;
37599
37600 wxPyEndAllowThreads(__tstate);
37601 if (PyErr_Occurred()) SWIG_fail;
37602 }
37603 resultobj = SWIG_Py_Void();
37604 return resultobj;
37605 fail:
37606 return NULL;
37607 }
37608
37609
37610 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37611 PyObject *resultobj = 0;
37612 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37613 wxString *arg2 = 0 ;
37614 void *argp1 = 0 ;
37615 int res1 = 0 ;
37616 bool temp2 = false ;
37617 PyObject * obj0 = 0 ;
37618 PyObject * obj1 = 0 ;
37619 char * kwnames[] = {
37620 (char *) "self",(char *) "name", NULL
37621 };
37622
37623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37625 if (!SWIG_IsOK(res1)) {
37626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37627 }
37628 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37629 {
37630 arg2 = wxString_in_helper(obj1);
37631 if (arg2 == NULL) SWIG_fail;
37632 temp2 = true;
37633 }
37634 {
37635 PyThreadState* __tstate = wxPyBeginAllowThreads();
37636 (arg1)->SetName((wxString const &)*arg2);
37637 wxPyEndAllowThreads(__tstate);
37638 if (PyErr_Occurred()) SWIG_fail;
37639 }
37640 resultobj = SWIG_Py_Void();
37641 {
37642 if (temp2)
37643 delete arg2;
37644 }
37645 return resultobj;
37646 fail:
37647 {
37648 if (temp2)
37649 delete arg2;
37650 }
37651 return NULL;
37652 }
37653
37654
37655 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37656 PyObject *resultobj = 0;
37657 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37658 wxString result;
37659 void *argp1 = 0 ;
37660 int res1 = 0 ;
37661 PyObject *swig_obj[1] ;
37662
37663 if (!args) SWIG_fail;
37664 swig_obj[0] = args;
37665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37666 if (!SWIG_IsOK(res1)) {
37667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37668 }
37669 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37670 {
37671 PyThreadState* __tstate = wxPyBeginAllowThreads();
37672 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37673 wxPyEndAllowThreads(__tstate);
37674 if (PyErr_Occurred()) SWIG_fail;
37675 }
37676 {
37677 #if wxUSE_UNICODE
37678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37679 #else
37680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37681 #endif
37682 }
37683 return resultobj;
37684 fail:
37685 return NULL;
37686 }
37687
37688
37689 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37690 PyObject *resultobj = 0;
37691 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37692 wxString *arg2 = 0 ;
37693 void *argp1 = 0 ;
37694 int res1 = 0 ;
37695 bool temp2 = false ;
37696 PyObject * obj0 = 0 ;
37697 PyObject * obj1 = 0 ;
37698 char * kwnames[] = {
37699 (char *) "self",(char *) "version", NULL
37700 };
37701
37702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37704 if (!SWIG_IsOK(res1)) {
37705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37706 }
37707 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37708 {
37709 arg2 = wxString_in_helper(obj1);
37710 if (arg2 == NULL) SWIG_fail;
37711 temp2 = true;
37712 }
37713 {
37714 PyThreadState* __tstate = wxPyBeginAllowThreads();
37715 (arg1)->SetVersion((wxString const &)*arg2);
37716 wxPyEndAllowThreads(__tstate);
37717 if (PyErr_Occurred()) SWIG_fail;
37718 }
37719 resultobj = SWIG_Py_Void();
37720 {
37721 if (temp2)
37722 delete arg2;
37723 }
37724 return resultobj;
37725 fail:
37726 {
37727 if (temp2)
37728 delete arg2;
37729 }
37730 return NULL;
37731 }
37732
37733
37734 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37735 PyObject *resultobj = 0;
37736 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37737 bool result;
37738 void *argp1 = 0 ;
37739 int res1 = 0 ;
37740 PyObject *swig_obj[1] ;
37741
37742 if (!args) SWIG_fail;
37743 swig_obj[0] = args;
37744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37745 if (!SWIG_IsOK(res1)) {
37746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37747 }
37748 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37749 {
37750 PyThreadState* __tstate = wxPyBeginAllowThreads();
37751 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37752 wxPyEndAllowThreads(__tstate);
37753 if (PyErr_Occurred()) SWIG_fail;
37754 }
37755 {
37756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37757 }
37758 return resultobj;
37759 fail:
37760 return NULL;
37761 }
37762
37763
37764 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37765 PyObject *resultobj = 0;
37766 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37767 wxString result;
37768 void *argp1 = 0 ;
37769 int res1 = 0 ;
37770 PyObject *swig_obj[1] ;
37771
37772 if (!args) SWIG_fail;
37773 swig_obj[0] = args;
37774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37775 if (!SWIG_IsOK(res1)) {
37776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37777 }
37778 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37779 {
37780 PyThreadState* __tstate = wxPyBeginAllowThreads();
37781 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37782 wxPyEndAllowThreads(__tstate);
37783 if (PyErr_Occurred()) SWIG_fail;
37784 }
37785 {
37786 #if wxUSE_UNICODE
37787 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37788 #else
37789 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37790 #endif
37791 }
37792 return resultobj;
37793 fail:
37794 return NULL;
37795 }
37796
37797
37798 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37799 PyObject *resultobj = 0;
37800 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37801 wxString *arg2 = 0 ;
37802 void *argp1 = 0 ;
37803 int res1 = 0 ;
37804 bool temp2 = false ;
37805 PyObject * obj0 = 0 ;
37806 PyObject * obj1 = 0 ;
37807 char * kwnames[] = {
37808 (char *) "self",(char *) "desc", NULL
37809 };
37810
37811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37813 if (!SWIG_IsOK(res1)) {
37814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37815 }
37816 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37817 {
37818 arg2 = wxString_in_helper(obj1);
37819 if (arg2 == NULL) SWIG_fail;
37820 temp2 = true;
37821 }
37822 {
37823 PyThreadState* __tstate = wxPyBeginAllowThreads();
37824 (arg1)->SetDescription((wxString const &)*arg2);
37825 wxPyEndAllowThreads(__tstate);
37826 if (PyErr_Occurred()) SWIG_fail;
37827 }
37828 resultobj = SWIG_Py_Void();
37829 {
37830 if (temp2)
37831 delete arg2;
37832 }
37833 return resultobj;
37834 fail:
37835 {
37836 if (temp2)
37837 delete arg2;
37838 }
37839 return NULL;
37840 }
37841
37842
37843 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37844 PyObject *resultobj = 0;
37845 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37846 bool result;
37847 void *argp1 = 0 ;
37848 int res1 = 0 ;
37849 PyObject *swig_obj[1] ;
37850
37851 if (!args) SWIG_fail;
37852 swig_obj[0] = args;
37853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37854 if (!SWIG_IsOK(res1)) {
37855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37856 }
37857 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37858 {
37859 PyThreadState* __tstate = wxPyBeginAllowThreads();
37860 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37861 wxPyEndAllowThreads(__tstate);
37862 if (PyErr_Occurred()) SWIG_fail;
37863 }
37864 {
37865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37866 }
37867 return resultobj;
37868 fail:
37869 return NULL;
37870 }
37871
37872
37873 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37874 PyObject *resultobj = 0;
37875 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37876 wxString result;
37877 void *argp1 = 0 ;
37878 int res1 = 0 ;
37879 PyObject *swig_obj[1] ;
37880
37881 if (!args) SWIG_fail;
37882 swig_obj[0] = args;
37883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37884 if (!SWIG_IsOK(res1)) {
37885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37886 }
37887 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37888 {
37889 PyThreadState* __tstate = wxPyBeginAllowThreads();
37890 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37891 wxPyEndAllowThreads(__tstate);
37892 if (PyErr_Occurred()) SWIG_fail;
37893 }
37894 {
37895 #if wxUSE_UNICODE
37896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37897 #else
37898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37899 #endif
37900 }
37901 return resultobj;
37902 fail:
37903 return NULL;
37904 }
37905
37906
37907 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37908 PyObject *resultobj = 0;
37909 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37910 wxString *arg2 = 0 ;
37911 void *argp1 = 0 ;
37912 int res1 = 0 ;
37913 bool temp2 = false ;
37914 PyObject * obj0 = 0 ;
37915 PyObject * obj1 = 0 ;
37916 char * kwnames[] = {
37917 (char *) "self",(char *) "copyright", NULL
37918 };
37919
37920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37922 if (!SWIG_IsOK(res1)) {
37923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37924 }
37925 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37926 {
37927 arg2 = wxString_in_helper(obj1);
37928 if (arg2 == NULL) SWIG_fail;
37929 temp2 = true;
37930 }
37931 {
37932 PyThreadState* __tstate = wxPyBeginAllowThreads();
37933 (arg1)->SetCopyright((wxString const &)*arg2);
37934 wxPyEndAllowThreads(__tstate);
37935 if (PyErr_Occurred()) SWIG_fail;
37936 }
37937 resultobj = SWIG_Py_Void();
37938 {
37939 if (temp2)
37940 delete arg2;
37941 }
37942 return resultobj;
37943 fail:
37944 {
37945 if (temp2)
37946 delete arg2;
37947 }
37948 return NULL;
37949 }
37950
37951
37952 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37953 PyObject *resultobj = 0;
37954 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37955 bool result;
37956 void *argp1 = 0 ;
37957 int res1 = 0 ;
37958 PyObject *swig_obj[1] ;
37959
37960 if (!args) SWIG_fail;
37961 swig_obj[0] = args;
37962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37963 if (!SWIG_IsOK(res1)) {
37964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37965 }
37966 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37967 {
37968 PyThreadState* __tstate = wxPyBeginAllowThreads();
37969 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37970 wxPyEndAllowThreads(__tstate);
37971 if (PyErr_Occurred()) SWIG_fail;
37972 }
37973 {
37974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37975 }
37976 return resultobj;
37977 fail:
37978 return NULL;
37979 }
37980
37981
37982 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37983 PyObject *resultobj = 0;
37984 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37985 wxString result;
37986 void *argp1 = 0 ;
37987 int res1 = 0 ;
37988 PyObject *swig_obj[1] ;
37989
37990 if (!args) SWIG_fail;
37991 swig_obj[0] = args;
37992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37993 if (!SWIG_IsOK(res1)) {
37994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37995 }
37996 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37997 {
37998 PyThreadState* __tstate = wxPyBeginAllowThreads();
37999 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
38000 wxPyEndAllowThreads(__tstate);
38001 if (PyErr_Occurred()) SWIG_fail;
38002 }
38003 {
38004 #if wxUSE_UNICODE
38005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38006 #else
38007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38008 #endif
38009 }
38010 return resultobj;
38011 fail:
38012 return NULL;
38013 }
38014
38015
38016 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38017 PyObject *resultobj = 0;
38018 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38019 wxString *arg2 = 0 ;
38020 void *argp1 = 0 ;
38021 int res1 = 0 ;
38022 bool temp2 = false ;
38023 PyObject * obj0 = 0 ;
38024 PyObject * obj1 = 0 ;
38025 char * kwnames[] = {
38026 (char *) "self",(char *) "licence", NULL
38027 };
38028
38029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
38030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38031 if (!SWIG_IsOK(res1)) {
38032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38033 }
38034 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38035 {
38036 arg2 = wxString_in_helper(obj1);
38037 if (arg2 == NULL) SWIG_fail;
38038 temp2 = true;
38039 }
38040 {
38041 PyThreadState* __tstate = wxPyBeginAllowThreads();
38042 (arg1)->SetLicence((wxString const &)*arg2);
38043 wxPyEndAllowThreads(__tstate);
38044 if (PyErr_Occurred()) SWIG_fail;
38045 }
38046 resultobj = SWIG_Py_Void();
38047 {
38048 if (temp2)
38049 delete arg2;
38050 }
38051 return resultobj;
38052 fail:
38053 {
38054 if (temp2)
38055 delete arg2;
38056 }
38057 return NULL;
38058 }
38059
38060
38061 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38062 PyObject *resultobj = 0;
38063 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38064 wxString *arg2 = 0 ;
38065 void *argp1 = 0 ;
38066 int res1 = 0 ;
38067 bool temp2 = false ;
38068 PyObject * obj0 = 0 ;
38069 PyObject * obj1 = 0 ;
38070 char * kwnames[] = {
38071 (char *) "self",(char *) "licence", NULL
38072 };
38073
38074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38076 if (!SWIG_IsOK(res1)) {
38077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38078 }
38079 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38080 {
38081 arg2 = wxString_in_helper(obj1);
38082 if (arg2 == NULL) SWIG_fail;
38083 temp2 = true;
38084 }
38085 {
38086 PyThreadState* __tstate = wxPyBeginAllowThreads();
38087 (arg1)->SetLicense((wxString const &)*arg2);
38088 wxPyEndAllowThreads(__tstate);
38089 if (PyErr_Occurred()) SWIG_fail;
38090 }
38091 resultobj = SWIG_Py_Void();
38092 {
38093 if (temp2)
38094 delete arg2;
38095 }
38096 return resultobj;
38097 fail:
38098 {
38099 if (temp2)
38100 delete arg2;
38101 }
38102 return NULL;
38103 }
38104
38105
38106 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38107 PyObject *resultobj = 0;
38108 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38109 bool result;
38110 void *argp1 = 0 ;
38111 int res1 = 0 ;
38112 PyObject *swig_obj[1] ;
38113
38114 if (!args) SWIG_fail;
38115 swig_obj[0] = args;
38116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38117 if (!SWIG_IsOK(res1)) {
38118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38119 }
38120 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38121 {
38122 PyThreadState* __tstate = wxPyBeginAllowThreads();
38123 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38124 wxPyEndAllowThreads(__tstate);
38125 if (PyErr_Occurred()) SWIG_fail;
38126 }
38127 {
38128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38129 }
38130 return resultobj;
38131 fail:
38132 return NULL;
38133 }
38134
38135
38136 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38137 PyObject *resultobj = 0;
38138 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38139 wxString result;
38140 void *argp1 = 0 ;
38141 int res1 = 0 ;
38142 PyObject *swig_obj[1] ;
38143
38144 if (!args) SWIG_fail;
38145 swig_obj[0] = args;
38146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38147 if (!SWIG_IsOK(res1)) {
38148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38149 }
38150 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38151 {
38152 PyThreadState* __tstate = wxPyBeginAllowThreads();
38153 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38154 wxPyEndAllowThreads(__tstate);
38155 if (PyErr_Occurred()) SWIG_fail;
38156 }
38157 {
38158 #if wxUSE_UNICODE
38159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38160 #else
38161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38162 #endif
38163 }
38164 return resultobj;
38165 fail:
38166 return NULL;
38167 }
38168
38169
38170 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38171 PyObject *resultobj = 0;
38172 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38173 wxIcon *arg2 = 0 ;
38174 void *argp1 = 0 ;
38175 int res1 = 0 ;
38176 void *argp2 = 0 ;
38177 int res2 = 0 ;
38178 PyObject * obj0 = 0 ;
38179 PyObject * obj1 = 0 ;
38180 char * kwnames[] = {
38181 (char *) "self",(char *) "icon", NULL
38182 };
38183
38184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38186 if (!SWIG_IsOK(res1)) {
38187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38188 }
38189 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38190 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38191 if (!SWIG_IsOK(res2)) {
38192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38193 }
38194 if (!argp2) {
38195 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38196 }
38197 arg2 = reinterpret_cast< wxIcon * >(argp2);
38198 {
38199 PyThreadState* __tstate = wxPyBeginAllowThreads();
38200 (arg1)->SetIcon((wxIcon const &)*arg2);
38201 wxPyEndAllowThreads(__tstate);
38202 if (PyErr_Occurred()) SWIG_fail;
38203 }
38204 resultobj = SWIG_Py_Void();
38205 return resultobj;
38206 fail:
38207 return NULL;
38208 }
38209
38210
38211 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38212 PyObject *resultobj = 0;
38213 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38214 bool result;
38215 void *argp1 = 0 ;
38216 int res1 = 0 ;
38217 PyObject *swig_obj[1] ;
38218
38219 if (!args) SWIG_fail;
38220 swig_obj[0] = args;
38221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38222 if (!SWIG_IsOK(res1)) {
38223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38224 }
38225 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38226 {
38227 PyThreadState* __tstate = wxPyBeginAllowThreads();
38228 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38229 wxPyEndAllowThreads(__tstate);
38230 if (PyErr_Occurred()) SWIG_fail;
38231 }
38232 {
38233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38234 }
38235 return resultobj;
38236 fail:
38237 return NULL;
38238 }
38239
38240
38241 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38242 PyObject *resultobj = 0;
38243 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38244 wxIcon result;
38245 void *argp1 = 0 ;
38246 int res1 = 0 ;
38247 PyObject *swig_obj[1] ;
38248
38249 if (!args) SWIG_fail;
38250 swig_obj[0] = args;
38251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38252 if (!SWIG_IsOK(res1)) {
38253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38254 }
38255 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38256 {
38257 PyThreadState* __tstate = wxPyBeginAllowThreads();
38258 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38259 wxPyEndAllowThreads(__tstate);
38260 if (PyErr_Occurred()) SWIG_fail;
38261 }
38262 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38263 return resultobj;
38264 fail:
38265 return NULL;
38266 }
38267
38268
38269 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38270 PyObject *resultobj = 0;
38271 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38272 wxString *arg2 = 0 ;
38273 wxString const &arg3_defvalue = wxEmptyString ;
38274 wxString *arg3 = (wxString *) &arg3_defvalue ;
38275 void *argp1 = 0 ;
38276 int res1 = 0 ;
38277 bool temp2 = false ;
38278 bool temp3 = false ;
38279 PyObject * obj0 = 0 ;
38280 PyObject * obj1 = 0 ;
38281 PyObject * obj2 = 0 ;
38282 char * kwnames[] = {
38283 (char *) "self",(char *) "url",(char *) "desc", NULL
38284 };
38285
38286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38288 if (!SWIG_IsOK(res1)) {
38289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38290 }
38291 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38292 {
38293 arg2 = wxString_in_helper(obj1);
38294 if (arg2 == NULL) SWIG_fail;
38295 temp2 = true;
38296 }
38297 if (obj2) {
38298 {
38299 arg3 = wxString_in_helper(obj2);
38300 if (arg3 == NULL) SWIG_fail;
38301 temp3 = true;
38302 }
38303 }
38304 {
38305 PyThreadState* __tstate = wxPyBeginAllowThreads();
38306 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38307 wxPyEndAllowThreads(__tstate);
38308 if (PyErr_Occurred()) SWIG_fail;
38309 }
38310 resultobj = SWIG_Py_Void();
38311 {
38312 if (temp2)
38313 delete arg2;
38314 }
38315 {
38316 if (temp3)
38317 delete arg3;
38318 }
38319 return resultobj;
38320 fail:
38321 {
38322 if (temp2)
38323 delete arg2;
38324 }
38325 {
38326 if (temp3)
38327 delete arg3;
38328 }
38329 return NULL;
38330 }
38331
38332
38333 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38334 PyObject *resultobj = 0;
38335 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38336 wxString result;
38337 void *argp1 = 0 ;
38338 int res1 = 0 ;
38339 PyObject *swig_obj[1] ;
38340
38341 if (!args) SWIG_fail;
38342 swig_obj[0] = args;
38343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38344 if (!SWIG_IsOK(res1)) {
38345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38346 }
38347 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38348 {
38349 PyThreadState* __tstate = wxPyBeginAllowThreads();
38350 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38351 wxPyEndAllowThreads(__tstate);
38352 if (PyErr_Occurred()) SWIG_fail;
38353 }
38354 {
38355 #if wxUSE_UNICODE
38356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38357 #else
38358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38359 #endif
38360 }
38361 return resultobj;
38362 fail:
38363 return NULL;
38364 }
38365
38366
38367 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38368 PyObject *resultobj = 0;
38369 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38370 wxString result;
38371 void *argp1 = 0 ;
38372 int res1 = 0 ;
38373 PyObject *swig_obj[1] ;
38374
38375 if (!args) SWIG_fail;
38376 swig_obj[0] = args;
38377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38378 if (!SWIG_IsOK(res1)) {
38379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38380 }
38381 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38382 {
38383 PyThreadState* __tstate = wxPyBeginAllowThreads();
38384 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38385 wxPyEndAllowThreads(__tstate);
38386 if (PyErr_Occurred()) SWIG_fail;
38387 }
38388 {
38389 #if wxUSE_UNICODE
38390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38391 #else
38392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38393 #endif
38394 }
38395 return resultobj;
38396 fail:
38397 return NULL;
38398 }
38399
38400
38401 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38402 PyObject *resultobj = 0;
38403 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38404 bool result;
38405 void *argp1 = 0 ;
38406 int res1 = 0 ;
38407 PyObject *swig_obj[1] ;
38408
38409 if (!args) SWIG_fail;
38410 swig_obj[0] = args;
38411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38412 if (!SWIG_IsOK(res1)) {
38413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38414 }
38415 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38416 {
38417 PyThreadState* __tstate = wxPyBeginAllowThreads();
38418 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38419 wxPyEndAllowThreads(__tstate);
38420 if (PyErr_Occurred()) SWIG_fail;
38421 }
38422 {
38423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38424 }
38425 return resultobj;
38426 fail:
38427 return NULL;
38428 }
38429
38430
38431 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38432 PyObject *resultobj = 0;
38433 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38434 wxArrayString *arg2 = 0 ;
38435 void *argp1 = 0 ;
38436 int res1 = 0 ;
38437 bool temp2 = false ;
38438 PyObject * obj0 = 0 ;
38439 PyObject * obj1 = 0 ;
38440 char * kwnames[] = {
38441 (char *) "self",(char *) "developers", NULL
38442 };
38443
38444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38446 if (!SWIG_IsOK(res1)) {
38447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38448 }
38449 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38450 {
38451 if (! PySequence_Check(obj1)) {
38452 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38453 SWIG_fail;
38454 }
38455 arg2 = new wxArrayString;
38456 temp2 = true;
38457 int i, len=PySequence_Length(obj1);
38458 for (i=0; i<len; i++) {
38459 PyObject* item = PySequence_GetItem(obj1, i);
38460 wxString* s = wxString_in_helper(item);
38461 if (PyErr_Occurred()) SWIG_fail;
38462 arg2->Add(*s);
38463 delete s;
38464 Py_DECREF(item);
38465 }
38466 }
38467 {
38468 PyThreadState* __tstate = wxPyBeginAllowThreads();
38469 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38470 wxPyEndAllowThreads(__tstate);
38471 if (PyErr_Occurred()) SWIG_fail;
38472 }
38473 resultobj = SWIG_Py_Void();
38474 {
38475 if (temp2) delete arg2;
38476 }
38477 return resultobj;
38478 fail:
38479 {
38480 if (temp2) delete arg2;
38481 }
38482 return NULL;
38483 }
38484
38485
38486 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38487 PyObject *resultobj = 0;
38488 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38489 wxString *arg2 = 0 ;
38490 void *argp1 = 0 ;
38491 int res1 = 0 ;
38492 bool temp2 = false ;
38493 PyObject * obj0 = 0 ;
38494 PyObject * obj1 = 0 ;
38495 char * kwnames[] = {
38496 (char *) "self",(char *) "developer", NULL
38497 };
38498
38499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38501 if (!SWIG_IsOK(res1)) {
38502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38503 }
38504 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38505 {
38506 arg2 = wxString_in_helper(obj1);
38507 if (arg2 == NULL) SWIG_fail;
38508 temp2 = true;
38509 }
38510 {
38511 PyThreadState* __tstate = wxPyBeginAllowThreads();
38512 (arg1)->AddDeveloper((wxString const &)*arg2);
38513 wxPyEndAllowThreads(__tstate);
38514 if (PyErr_Occurred()) SWIG_fail;
38515 }
38516 resultobj = SWIG_Py_Void();
38517 {
38518 if (temp2)
38519 delete arg2;
38520 }
38521 return resultobj;
38522 fail:
38523 {
38524 if (temp2)
38525 delete arg2;
38526 }
38527 return NULL;
38528 }
38529
38530
38531 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38532 PyObject *resultobj = 0;
38533 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38534 bool result;
38535 void *argp1 = 0 ;
38536 int res1 = 0 ;
38537 PyObject *swig_obj[1] ;
38538
38539 if (!args) SWIG_fail;
38540 swig_obj[0] = args;
38541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38542 if (!SWIG_IsOK(res1)) {
38543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38544 }
38545 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38546 {
38547 PyThreadState* __tstate = wxPyBeginAllowThreads();
38548 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38549 wxPyEndAllowThreads(__tstate);
38550 if (PyErr_Occurred()) SWIG_fail;
38551 }
38552 {
38553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38554 }
38555 return resultobj;
38556 fail:
38557 return NULL;
38558 }
38559
38560
38561 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38562 PyObject *resultobj = 0;
38563 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38564 wxArrayString *result = 0 ;
38565 void *argp1 = 0 ;
38566 int res1 = 0 ;
38567 PyObject *swig_obj[1] ;
38568
38569 if (!args) SWIG_fail;
38570 swig_obj[0] = args;
38571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38572 if (!SWIG_IsOK(res1)) {
38573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38574 }
38575 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38576 {
38577 PyThreadState* __tstate = wxPyBeginAllowThreads();
38578 {
38579 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38580 result = (wxArrayString *) &_result_ref;
38581 }
38582 wxPyEndAllowThreads(__tstate);
38583 if (PyErr_Occurred()) SWIG_fail;
38584 }
38585 {
38586 resultobj = wxArrayString2PyList_helper(*result);
38587 }
38588 return resultobj;
38589 fail:
38590 return NULL;
38591 }
38592
38593
38594 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38595 PyObject *resultobj = 0;
38596 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38597 wxArrayString *arg2 = 0 ;
38598 void *argp1 = 0 ;
38599 int res1 = 0 ;
38600 bool temp2 = false ;
38601 PyObject * obj0 = 0 ;
38602 PyObject * obj1 = 0 ;
38603 char * kwnames[] = {
38604 (char *) "self",(char *) "docwriters", NULL
38605 };
38606
38607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38609 if (!SWIG_IsOK(res1)) {
38610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38611 }
38612 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38613 {
38614 if (! PySequence_Check(obj1)) {
38615 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38616 SWIG_fail;
38617 }
38618 arg2 = new wxArrayString;
38619 temp2 = true;
38620 int i, len=PySequence_Length(obj1);
38621 for (i=0; i<len; i++) {
38622 PyObject* item = PySequence_GetItem(obj1, i);
38623 wxString* s = wxString_in_helper(item);
38624 if (PyErr_Occurred()) SWIG_fail;
38625 arg2->Add(*s);
38626 delete s;
38627 Py_DECREF(item);
38628 }
38629 }
38630 {
38631 PyThreadState* __tstate = wxPyBeginAllowThreads();
38632 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38633 wxPyEndAllowThreads(__tstate);
38634 if (PyErr_Occurred()) SWIG_fail;
38635 }
38636 resultobj = SWIG_Py_Void();
38637 {
38638 if (temp2) delete arg2;
38639 }
38640 return resultobj;
38641 fail:
38642 {
38643 if (temp2) delete arg2;
38644 }
38645 return NULL;
38646 }
38647
38648
38649 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38650 PyObject *resultobj = 0;
38651 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38652 wxString *arg2 = 0 ;
38653 void *argp1 = 0 ;
38654 int res1 = 0 ;
38655 bool temp2 = false ;
38656 PyObject * obj0 = 0 ;
38657 PyObject * obj1 = 0 ;
38658 char * kwnames[] = {
38659 (char *) "self",(char *) "docwriter", NULL
38660 };
38661
38662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38664 if (!SWIG_IsOK(res1)) {
38665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38666 }
38667 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38668 {
38669 arg2 = wxString_in_helper(obj1);
38670 if (arg2 == NULL) SWIG_fail;
38671 temp2 = true;
38672 }
38673 {
38674 PyThreadState* __tstate = wxPyBeginAllowThreads();
38675 (arg1)->AddDocWriter((wxString const &)*arg2);
38676 wxPyEndAllowThreads(__tstate);
38677 if (PyErr_Occurred()) SWIG_fail;
38678 }
38679 resultobj = SWIG_Py_Void();
38680 {
38681 if (temp2)
38682 delete arg2;
38683 }
38684 return resultobj;
38685 fail:
38686 {
38687 if (temp2)
38688 delete arg2;
38689 }
38690 return NULL;
38691 }
38692
38693
38694 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38695 PyObject *resultobj = 0;
38696 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38697 bool result;
38698 void *argp1 = 0 ;
38699 int res1 = 0 ;
38700 PyObject *swig_obj[1] ;
38701
38702 if (!args) SWIG_fail;
38703 swig_obj[0] = args;
38704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38705 if (!SWIG_IsOK(res1)) {
38706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38707 }
38708 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38709 {
38710 PyThreadState* __tstate = wxPyBeginAllowThreads();
38711 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38712 wxPyEndAllowThreads(__tstate);
38713 if (PyErr_Occurred()) SWIG_fail;
38714 }
38715 {
38716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38717 }
38718 return resultobj;
38719 fail:
38720 return NULL;
38721 }
38722
38723
38724 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38725 PyObject *resultobj = 0;
38726 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38727 wxArrayString *result = 0 ;
38728 void *argp1 = 0 ;
38729 int res1 = 0 ;
38730 PyObject *swig_obj[1] ;
38731
38732 if (!args) SWIG_fail;
38733 swig_obj[0] = args;
38734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38735 if (!SWIG_IsOK(res1)) {
38736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38737 }
38738 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 {
38742 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38743 result = (wxArrayString *) &_result_ref;
38744 }
38745 wxPyEndAllowThreads(__tstate);
38746 if (PyErr_Occurred()) SWIG_fail;
38747 }
38748 {
38749 resultobj = wxArrayString2PyList_helper(*result);
38750 }
38751 return resultobj;
38752 fail:
38753 return NULL;
38754 }
38755
38756
38757 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38758 PyObject *resultobj = 0;
38759 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38760 wxArrayString *arg2 = 0 ;
38761 void *argp1 = 0 ;
38762 int res1 = 0 ;
38763 bool temp2 = false ;
38764 PyObject * obj0 = 0 ;
38765 PyObject * obj1 = 0 ;
38766 char * kwnames[] = {
38767 (char *) "self",(char *) "artists", NULL
38768 };
38769
38770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38772 if (!SWIG_IsOK(res1)) {
38773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38774 }
38775 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38776 {
38777 if (! PySequence_Check(obj1)) {
38778 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38779 SWIG_fail;
38780 }
38781 arg2 = new wxArrayString;
38782 temp2 = true;
38783 int i, len=PySequence_Length(obj1);
38784 for (i=0; i<len; i++) {
38785 PyObject* item = PySequence_GetItem(obj1, i);
38786 wxString* s = wxString_in_helper(item);
38787 if (PyErr_Occurred()) SWIG_fail;
38788 arg2->Add(*s);
38789 delete s;
38790 Py_DECREF(item);
38791 }
38792 }
38793 {
38794 PyThreadState* __tstate = wxPyBeginAllowThreads();
38795 (arg1)->SetArtists((wxArrayString const &)*arg2);
38796 wxPyEndAllowThreads(__tstate);
38797 if (PyErr_Occurred()) SWIG_fail;
38798 }
38799 resultobj = SWIG_Py_Void();
38800 {
38801 if (temp2) delete arg2;
38802 }
38803 return resultobj;
38804 fail:
38805 {
38806 if (temp2) delete arg2;
38807 }
38808 return NULL;
38809 }
38810
38811
38812 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38813 PyObject *resultobj = 0;
38814 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38815 wxString *arg2 = 0 ;
38816 void *argp1 = 0 ;
38817 int res1 = 0 ;
38818 bool temp2 = false ;
38819 PyObject * obj0 = 0 ;
38820 PyObject * obj1 = 0 ;
38821 char * kwnames[] = {
38822 (char *) "self",(char *) "artist", NULL
38823 };
38824
38825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38827 if (!SWIG_IsOK(res1)) {
38828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38829 }
38830 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38831 {
38832 arg2 = wxString_in_helper(obj1);
38833 if (arg2 == NULL) SWIG_fail;
38834 temp2 = true;
38835 }
38836 {
38837 PyThreadState* __tstate = wxPyBeginAllowThreads();
38838 (arg1)->AddArtist((wxString const &)*arg2);
38839 wxPyEndAllowThreads(__tstate);
38840 if (PyErr_Occurred()) SWIG_fail;
38841 }
38842 resultobj = SWIG_Py_Void();
38843 {
38844 if (temp2)
38845 delete arg2;
38846 }
38847 return resultobj;
38848 fail:
38849 {
38850 if (temp2)
38851 delete arg2;
38852 }
38853 return NULL;
38854 }
38855
38856
38857 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38858 PyObject *resultobj = 0;
38859 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38860 bool result;
38861 void *argp1 = 0 ;
38862 int res1 = 0 ;
38863 PyObject *swig_obj[1] ;
38864
38865 if (!args) SWIG_fail;
38866 swig_obj[0] = args;
38867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38868 if (!SWIG_IsOK(res1)) {
38869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38870 }
38871 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38872 {
38873 PyThreadState* __tstate = wxPyBeginAllowThreads();
38874 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38875 wxPyEndAllowThreads(__tstate);
38876 if (PyErr_Occurred()) SWIG_fail;
38877 }
38878 {
38879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38880 }
38881 return resultobj;
38882 fail:
38883 return NULL;
38884 }
38885
38886
38887 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38888 PyObject *resultobj = 0;
38889 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38890 wxArrayString *result = 0 ;
38891 void *argp1 = 0 ;
38892 int res1 = 0 ;
38893 PyObject *swig_obj[1] ;
38894
38895 if (!args) SWIG_fail;
38896 swig_obj[0] = args;
38897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38898 if (!SWIG_IsOK(res1)) {
38899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38900 }
38901 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38902 {
38903 PyThreadState* __tstate = wxPyBeginAllowThreads();
38904 {
38905 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38906 result = (wxArrayString *) &_result_ref;
38907 }
38908 wxPyEndAllowThreads(__tstate);
38909 if (PyErr_Occurred()) SWIG_fail;
38910 }
38911 {
38912 resultobj = wxArrayString2PyList_helper(*result);
38913 }
38914 return resultobj;
38915 fail:
38916 return NULL;
38917 }
38918
38919
38920 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38921 PyObject *resultobj = 0;
38922 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38923 wxArrayString *arg2 = 0 ;
38924 void *argp1 = 0 ;
38925 int res1 = 0 ;
38926 bool temp2 = false ;
38927 PyObject * obj0 = 0 ;
38928 PyObject * obj1 = 0 ;
38929 char * kwnames[] = {
38930 (char *) "self",(char *) "translators", NULL
38931 };
38932
38933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38935 if (!SWIG_IsOK(res1)) {
38936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38937 }
38938 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38939 {
38940 if (! PySequence_Check(obj1)) {
38941 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38942 SWIG_fail;
38943 }
38944 arg2 = new wxArrayString;
38945 temp2 = true;
38946 int i, len=PySequence_Length(obj1);
38947 for (i=0; i<len; i++) {
38948 PyObject* item = PySequence_GetItem(obj1, i);
38949 wxString* s = wxString_in_helper(item);
38950 if (PyErr_Occurred()) SWIG_fail;
38951 arg2->Add(*s);
38952 delete s;
38953 Py_DECREF(item);
38954 }
38955 }
38956 {
38957 PyThreadState* __tstate = wxPyBeginAllowThreads();
38958 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38959 wxPyEndAllowThreads(__tstate);
38960 if (PyErr_Occurred()) SWIG_fail;
38961 }
38962 resultobj = SWIG_Py_Void();
38963 {
38964 if (temp2) delete arg2;
38965 }
38966 return resultobj;
38967 fail:
38968 {
38969 if (temp2) delete arg2;
38970 }
38971 return NULL;
38972 }
38973
38974
38975 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38976 PyObject *resultobj = 0;
38977 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38978 wxString *arg2 = 0 ;
38979 void *argp1 = 0 ;
38980 int res1 = 0 ;
38981 bool temp2 = false ;
38982 PyObject * obj0 = 0 ;
38983 PyObject * obj1 = 0 ;
38984 char * kwnames[] = {
38985 (char *) "self",(char *) "translator", NULL
38986 };
38987
38988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38990 if (!SWIG_IsOK(res1)) {
38991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38992 }
38993 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38994 {
38995 arg2 = wxString_in_helper(obj1);
38996 if (arg2 == NULL) SWIG_fail;
38997 temp2 = true;
38998 }
38999 {
39000 PyThreadState* __tstate = wxPyBeginAllowThreads();
39001 (arg1)->AddTranslator((wxString const &)*arg2);
39002 wxPyEndAllowThreads(__tstate);
39003 if (PyErr_Occurred()) SWIG_fail;
39004 }
39005 resultobj = SWIG_Py_Void();
39006 {
39007 if (temp2)
39008 delete arg2;
39009 }
39010 return resultobj;
39011 fail:
39012 {
39013 if (temp2)
39014 delete arg2;
39015 }
39016 return NULL;
39017 }
39018
39019
39020 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39021 PyObject *resultobj = 0;
39022 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39023 bool result;
39024 void *argp1 = 0 ;
39025 int res1 = 0 ;
39026 PyObject *swig_obj[1] ;
39027
39028 if (!args) SWIG_fail;
39029 swig_obj[0] = args;
39030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39031 if (!SWIG_IsOK(res1)) {
39032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39033 }
39034 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39035 {
39036 PyThreadState* __tstate = wxPyBeginAllowThreads();
39037 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39038 wxPyEndAllowThreads(__tstate);
39039 if (PyErr_Occurred()) SWIG_fail;
39040 }
39041 {
39042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39043 }
39044 return resultobj;
39045 fail:
39046 return NULL;
39047 }
39048
39049
39050 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39051 PyObject *resultobj = 0;
39052 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39053 wxArrayString *result = 0 ;
39054 void *argp1 = 0 ;
39055 int res1 = 0 ;
39056 PyObject *swig_obj[1] ;
39057
39058 if (!args) SWIG_fail;
39059 swig_obj[0] = args;
39060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39061 if (!SWIG_IsOK(res1)) {
39062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39063 }
39064 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39065 {
39066 PyThreadState* __tstate = wxPyBeginAllowThreads();
39067 {
39068 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39069 result = (wxArrayString *) &_result_ref;
39070 }
39071 wxPyEndAllowThreads(__tstate);
39072 if (PyErr_Occurred()) SWIG_fail;
39073 }
39074 {
39075 resultobj = wxArrayString2PyList_helper(*result);
39076 }
39077 return resultobj;
39078 fail:
39079 return NULL;
39080 }
39081
39082
39083 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39084 PyObject *resultobj = 0;
39085 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39086 bool result;
39087 void *argp1 = 0 ;
39088 int res1 = 0 ;
39089 PyObject *swig_obj[1] ;
39090
39091 if (!args) SWIG_fail;
39092 swig_obj[0] = args;
39093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39094 if (!SWIG_IsOK(res1)) {
39095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39096 }
39097 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39098 {
39099 PyThreadState* __tstate = wxPyBeginAllowThreads();
39100 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39101 wxPyEndAllowThreads(__tstate);
39102 if (PyErr_Occurred()) SWIG_fail;
39103 }
39104 {
39105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39106 }
39107 return resultobj;
39108 fail:
39109 return NULL;
39110 }
39111
39112
39113 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39114 PyObject *resultobj = 0;
39115 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39116 wxString result;
39117 void *argp1 = 0 ;
39118 int res1 = 0 ;
39119 PyObject *swig_obj[1] ;
39120
39121 if (!args) SWIG_fail;
39122 swig_obj[0] = args;
39123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39124 if (!SWIG_IsOK(res1)) {
39125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39126 }
39127 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39128 {
39129 PyThreadState* __tstate = wxPyBeginAllowThreads();
39130 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39131 wxPyEndAllowThreads(__tstate);
39132 if (PyErr_Occurred()) SWIG_fail;
39133 }
39134 {
39135 #if wxUSE_UNICODE
39136 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39137 #else
39138 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39139 #endif
39140 }
39141 return resultobj;
39142 fail:
39143 return NULL;
39144 }
39145
39146
39147 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39148 PyObject *obj;
39149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39150 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39151 return SWIG_Py_Void();
39152 }
39153
39154 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39155 return SWIG_Python_InitShadowInstance(args);
39156 }
39157
39158 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39159 PyObject *resultobj = 0;
39160 wxAboutDialogInfo *arg1 = 0 ;
39161 void *argp1 = 0 ;
39162 int res1 = 0 ;
39163 PyObject * obj0 = 0 ;
39164 char * kwnames[] = {
39165 (char *) "info", NULL
39166 };
39167
39168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39169 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39170 if (!SWIG_IsOK(res1)) {
39171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39172 }
39173 if (!argp1) {
39174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39175 }
39176 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39177 {
39178 PyThreadState* __tstate = wxPyBeginAllowThreads();
39179 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39180 wxPyEndAllowThreads(__tstate);
39181 if (PyErr_Occurred()) SWIG_fail;
39182 }
39183 resultobj = SWIG_Py_Void();
39184 return resultobj;
39185 fail:
39186 return NULL;
39187 }
39188
39189
39190 static PyMethodDef SwigMethods[] = {
39191 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39194 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39195 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39196 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39197 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39198 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39199 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39200 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39201 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39202 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39203 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39204 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39205 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39206 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39207 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39208 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39209 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39210 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39213 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39214 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39215 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39216 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39217 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39218 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39219 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39220 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39221 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39222 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39223 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39224 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39225 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39226 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39227 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39228 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39231 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39232 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39233 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39234 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39235 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39236 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39237 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39238 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39239 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39240 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39241 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39242 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39243 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39244 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39245 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39246 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39249 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39250 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39251 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39252 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39253 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39254 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39255 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39256 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39257 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39258 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39259 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39260 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39261 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39262 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39263 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39264 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39265 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39266 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39267 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39268 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39270 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39271 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39272 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39273 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39274 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39275 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39276 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39277 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39278 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39279 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39280 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39281 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39282 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39283 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39284 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39285 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39287 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39291 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39292 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39293 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39294 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39295 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39296 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39297 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39298 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39299 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39300 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39301 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39302 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39303 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39304 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39305 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39306 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39307 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39308 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39309 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39310 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39311 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39312 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39313 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39314 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39315 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39316 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39317 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39318 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39319 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39320 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39323 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39324 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39325 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39326 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39327 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39328 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39329 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39330 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39331 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39332 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39333 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39334 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39335 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39336 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39337 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39338 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39339 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39340 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39341 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39342 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39343 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39344 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39345 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39346 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39347 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39348 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39349 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39350 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39351 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39352 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39353 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39354 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39355 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39356 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39357 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39358 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39360 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39362 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39363 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39364 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39365 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39366 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39367 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39368 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39369 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39370 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39371 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39372 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39373 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39374 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39375 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39376 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39377 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39378 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39379 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39380 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39381 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39382 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39383 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39384 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39385 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39386 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39387 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39388 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39389 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39390 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39391 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39392 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39393 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39394 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39395 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39396 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39397 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39398 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39399 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39400 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39401 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39402 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39403 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39404 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39405 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39407 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39408 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39410 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39411 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39412 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39414 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39415 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39416 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39417 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39418 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39419 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39420 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39421 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39422 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39423 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39424 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39425 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39426 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39427 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39428 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39429 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39430 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39431 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39432 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39433 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39434 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39435 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39436 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39437 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39438 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39439 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39440 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39441 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39442 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39443 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39444 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39445 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39446 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39447 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39448 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39449 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39450 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39451 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39452 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39454 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39455 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39456 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39457 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39458 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39459 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39460 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39461 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39462 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39463 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39464 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39465 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39466 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39467 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39468 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39469 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39470 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39471 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39472 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39473 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39474 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39475 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39476 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39477 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39478 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39479 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39480 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39481 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39482 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39483 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39484 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39485 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39487 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39488 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39489 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39490 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39491 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39492 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39493 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39494 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39495 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39496 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39497 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39498 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39499 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39500 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39501 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39502 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39503 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39504 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39506 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39507 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39509 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39510 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39511 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39512 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39513 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39514 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39515 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39516 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39517 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39518 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39519 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39520 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39521 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39522 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39523 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39524 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39525 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39526 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39527 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39528 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39529 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39530 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39531 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39532 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39533 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39534 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39535 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39536 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39537 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39538 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39539 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39540 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39541 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39542 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39543 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39544 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39545 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39546 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39547 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39548 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39549 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39550 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39551 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39552 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39553 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39554 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39555 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39556 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39557 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39558 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39559 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39560 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39561 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39562 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39563 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39564 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39565 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39566 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39567 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39568 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39569 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39570 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39571 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39572 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39573 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39574 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39575 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39576 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39577 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39578 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39579 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39580 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39581 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39582 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39583 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39584 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39585 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39586 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39587 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39588 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39589 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39590 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39591 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39592 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39593 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39594 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39595 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39597 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39598 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39599 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39600 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39601 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39603 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39605 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39606 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39607 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39608 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39609 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39610 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39613 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39614 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39617 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39620 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39621 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39623 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39624 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39625 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39626 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39627 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39628 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39629 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39632 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39633 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39634 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39635 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39636 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39637 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39638 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39639 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39640 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39641 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39642 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39643 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39644 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39645 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39646 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39647 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39648 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39649 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39650 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39652 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39656 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39658 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39659 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39660 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39661 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39663 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39667 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39668 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39672 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39673 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39674 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39675 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39676 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39680 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39681 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39682 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39685 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39686 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39687 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39688 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39691 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39692 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39694 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39695 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39697 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39704 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39706 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39707 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39718 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39720 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39722 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39724 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39725 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39729 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39730 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39732 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39733 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39734 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39736 { (char *)"FileConfig_GetGlobalFileName", (PyCFunction) _wrap_FileConfig_GetGlobalFileName, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"FileConfig_GetLocalFileName", (PyCFunction) _wrap_FileConfig_GetLocalFileName, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39739 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39740 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39742 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39743 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39744 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39745 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39748 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39759 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39763 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39764 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39765 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39766 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39769 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39772 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39773 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39778 { (char *)"DateTime_GetDateOnly", (PyCFunction)_wrap_DateTime_GetDateOnly, METH_O, NULL},
39779 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39801 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39802 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39803 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39804 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39805 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39809 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39810 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39817 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39818 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39844 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39845 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39846 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39847 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39852 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39860 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39861 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39862 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39863 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39864 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39865 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39867 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39869 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39871 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39873 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39875 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39877 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39879 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39883 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39884 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39888 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39892 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39893 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39894 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39895 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39896 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39899 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39900 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39901 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39905 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39906 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39907 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39908 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39909 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39910 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39912 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39913 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39914 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39915 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39916 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39917 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39919 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39920 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39921 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39923 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39926 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39927 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39928 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39929 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39930 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39931 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39932 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39935 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39939 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39941 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39942 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39946 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39947 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39948 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39949 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39950 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39951 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39952 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39953 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39955 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39956 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39957 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39959 { (char *)"DataFormat__GetId", (PyCFunction)_wrap_DataFormat__GetId, METH_O, NULL},
39960 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39962 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39963 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39964 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39965 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39966 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39967 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39970 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39971 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39972 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39974 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39975 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39976 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39977 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39978 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39979 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39980 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39981 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39983 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39984 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39985 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39987 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39988 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39989 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39990 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39991 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39992 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39994 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39995 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39996 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39998 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39999 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
40001 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
40003 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
40004 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40005 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40006 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
40007 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
40008 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
40009 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
40010 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
40011 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
40012 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
40013 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
40014 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
40016 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
40017 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
40018 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
40019 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40020 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
40021 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
40023 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
40024 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
40025 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
40027 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
40028 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
40029 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
40030 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
40031 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40032 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
40033 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40034 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40035 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40036 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40037 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40038 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40039 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40040 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40042 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40043 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40044 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40045 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40046 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40047 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40048 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40049 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40050 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40051 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40052 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40053 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40054 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40055 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40056 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40057 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40058 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40059 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40060 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40061 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40062 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40063 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40064 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40065 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40068 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40069 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40070 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40071 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40072 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40073 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40074 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40075 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40076 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40077 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40078 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40079 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40080 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40081 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40082 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40083 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40084 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40085 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40086 { (char *)"Clipboard_IsUsingPrimarySelection", (PyCFunction)_wrap_Clipboard_IsUsingPrimarySelection, METH_O, NULL},
40087 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40088 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40089 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40090 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40091 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40092 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40093 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40094 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40095 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40096 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40097 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40098 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40099 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40100 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40101 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40102 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40103 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40104 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40105 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40106 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40107 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40108 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40109 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40110 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40111 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40112 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40113 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40114 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40115 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40116 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40117 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40118 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40119 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40120 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40121 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40122 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40123 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40124 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40125 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40126 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40127 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40128 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40129 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40130 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40131 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40132 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40133 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40134 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40135 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40136 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40137 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40138 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40139 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40140 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40141 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40142 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40143 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40144 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40145 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40146 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40147 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40148 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40149 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40150 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40151 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40152 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40153 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40154 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40155 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40156 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40157 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40158 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40159 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40160 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40161 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40162 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40163 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40164 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40165 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40166 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40167 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40168 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40169 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40170 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40171 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40172 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40173 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40174 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40175 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40176 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40177 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40178 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40179 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40180 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40181 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40182 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40183 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40184 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40185 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40186 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40187 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40188 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40189 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40190 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40191 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40192 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40193 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40194 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40195 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40196 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40197 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40198 { NULL, NULL, 0, NULL }
40199 };
40200
40201
40202 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40203
40204 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40205 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40206 }
40207 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40208 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40209 }
40210 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40211 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40212 }
40213 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40214 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40215 }
40216 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40217 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40218 }
40219 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40220 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40221 }
40222 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40223 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40224 }
40225 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40226 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40227 }
40228 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40229 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40230 }
40231 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40232 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40233 }
40234 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40235 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40236 }
40237 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40238 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40239 }
40240 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40241 return (void *)((wxEvent *) ((wxPyEvent *) x));
40242 }
40243 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40244 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40245 }
40246 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40247 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40248 }
40249 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40250 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40251 }
40252 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40253 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40254 }
40255 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40256 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40257 }
40258 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40259 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40260 }
40261 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40262 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40263 }
40264 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40265 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40266 }
40267 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40268 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40269 }
40270 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40271 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40272 }
40273 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40274 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40275 }
40276 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40277 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40278 }
40279 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40280 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40281 }
40282 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40283 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40284 }
40285 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40286 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40287 }
40288 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40289 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40290 }
40291 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40292 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40293 }
40294 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40295 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40296 }
40297 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40298 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40299 }
40300 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40301 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40302 }
40303 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40304 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40305 }
40306 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40307 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40308 }
40309 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40310 return (void *)((wxEvent *) ((wxShowEvent *) x));
40311 }
40312 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40313 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40314 }
40315 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40316 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40317 }
40318 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40319 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40320 }
40321 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40322 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40323 }
40324 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40325 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40326 }
40327 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40328 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40329 }
40330 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40331 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40332 }
40333 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40334 return (void *)((wxConfigBase *) ((wxConfig *) x));
40335 }
40336 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40337 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40338 }
40339 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40340 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40341 }
40342 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40343 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40344 }
40345 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40346 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40347 }
40348 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40349 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40350 }
40351 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40352 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40353 }
40354 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40355 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40356 }
40357 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40358 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40359 }
40360 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40361 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40362 }
40363 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40364 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40365 }
40366 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40367 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40368 }
40369 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40370 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40371 }
40372 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40373 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40374 }
40375 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40376 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40377 }
40378 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40379 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40380 }
40381 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40382 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40383 }
40384 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40385 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40386 }
40387 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40388 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40389 }
40390 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40391 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40392 }
40393 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40394 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40395 }
40396 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40397 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40398 }
40399 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40400 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40401 }
40402 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40403 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40404 }
40405 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40406 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40407 }
40408 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40409 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40410 }
40411 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40412 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40413 }
40414 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40415 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40416 }
40417 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40418 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40419 }
40420 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40421 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40422 }
40423 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
40424 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
40425 }
40426 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40427 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40428 }
40429 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40430 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40431 }
40432 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40433 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40434 }
40435 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40436 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40437 }
40438 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
40439 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
40440 }
40441 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40442 return (void *)((wxObject *) ((wxSizerItem *) x));
40443 }
40444 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40445 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40446 }
40447 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40448 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40449 }
40450 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40451 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40452 }
40453 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40454 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40455 }
40456 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40457 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40458 }
40459 static void *_p_wxSizerTo_p_wxObject(void *x) {
40460 return (void *)((wxObject *) ((wxSizer *) x));
40461 }
40462 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40463 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40464 }
40465 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40466 return (void *)((wxObject *) ((wxFileHistory *) x));
40467 }
40468 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40469 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40470 }
40471 static void *_p_wxEventTo_p_wxObject(void *x) {
40472 return (void *)((wxObject *) ((wxEvent *) x));
40473 }
40474 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40475 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40476 }
40477 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40478 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40479 }
40480 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40481 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40482 }
40483 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40485 }
40486 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40487 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40488 }
40489 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40490 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40491 }
40492 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40493 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40494 }
40495 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40496 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40497 }
40498 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40499 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40500 }
40501 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40502 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40503 }
40504 static void *_p_wxControlTo_p_wxObject(void *x) {
40505 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40506 }
40507 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40508 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40509 }
40510 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40511 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40512 }
40513 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40514 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40515 }
40516 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40517 return (void *)((wxObject *) ((wxFSFile *) x));
40518 }
40519 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40520 return (void *)((wxObject *) ((wxClipboard *) x));
40521 }
40522 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40523 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40524 }
40525 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40526 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40527 }
40528 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40529 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40530 }
40531 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40532 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40533 }
40534 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40535 return (void *)((wxObject *) ((wxToolTip *) x));
40536 }
40537 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40538 return (void *)((wxObject *) ((wxMenuItem *) x));
40539 }
40540 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40541 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40542 }
40543 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40544 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40545 }
40546 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40547 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40548 }
40549 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40550 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40551 }
40552 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40553 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40554 }
40555 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40556 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40557 }
40558 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40559 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40560 }
40561 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40562 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40563 }
40564 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40565 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40566 }
40567 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40568 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40569 }
40570 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40571 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40572 }
40573 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40574 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40575 }
40576 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40577 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40578 }
40579 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40580 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40581 }
40582 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40583 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40584 }
40585 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40586 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40587 }
40588 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40589 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40590 }
40591 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40592 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40593 }
40594 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40595 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40596 }
40597 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40598 return (void *)((wxObject *) ((wxImageHandler *) x));
40599 }
40600 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40601 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40602 }
40603 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40604 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40605 }
40606 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40607 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40608 }
40609 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40610 return (void *)((wxObject *) ((wxEvtHandler *) x));
40611 }
40612 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40613 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40614 }
40615 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40616 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40617 }
40618 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40619 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40620 }
40621 static void *_p_wxImageTo_p_wxObject(void *x) {
40622 return (void *)((wxObject *) ((wxImage *) x));
40623 }
40624 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40625 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40626 }
40627 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40628 return (void *)((wxObject *) ((wxSystemOptions *) x));
40629 }
40630 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40631 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40632 }
40633 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40634 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40635 }
40636 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40637 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40638 }
40639 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40640 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40641 }
40642 static void *_p_wxWindowTo_p_wxObject(void *x) {
40643 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40644 }
40645 static void *_p_wxMenuTo_p_wxObject(void *x) {
40646 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40647 }
40648 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40649 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40650 }
40651 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40652 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40653 }
40654 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40655 return (void *)((wxObject *) ((wxFileSystem *) x));
40656 }
40657 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40658 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40659 }
40660 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40661 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40662 }
40663 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40664 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40665 }
40666 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40667 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40668 }
40669 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40670 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40671 }
40672 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40673 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40674 }
40675 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40676 return (void *)((wxObject *) ((wxBusyInfo *) x));
40677 }
40678 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40679 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40680 }
40681 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40682 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40683 }
40684 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40685 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40686 }
40687 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40688 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40689 }
40690 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40691 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40692 }
40693 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40694 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40695 }
40696 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40697 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40698 }
40699 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40700 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40701 }
40702 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40703 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40704 }
40705 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40706 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40707 }
40708 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40709 return (void *)((wxLog *) ((wxLogBuffer *) x));
40710 }
40711 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40712 return (void *)((wxLog *) ((wxLogStderr *) x));
40713 }
40714 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40715 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40716 }
40717 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40718 return (void *)((wxLog *) ((wxLogWindow *) x));
40719 }
40720 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40721 return (void *)((wxLog *) ((wxLogChain *) x));
40722 }
40723 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40724 return (void *)((wxLog *) ((wxLogGui *) x));
40725 }
40726 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40727 return (void *)((wxLog *) ((wxPyLog *) x));
40728 }
40729 static void *_p_wxControlTo_p_wxWindow(void *x) {
40730 return (void *)((wxWindow *) ((wxControl *) x));
40731 }
40732 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40733 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40734 }
40735 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40736 return (void *)((wxWindow *) ((wxMenuBar *) x));
40737 }
40738 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40739 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40740 }
40741 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40742 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40743 }
40744 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40745 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, (void*)0, 0};
40746 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40747 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40748 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40749 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40750 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40751 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40752 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40753 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40754 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40755 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40756 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40757 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40758 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40759 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40760 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40761 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40762 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40763 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40764 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40765 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40766 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40767 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40768 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40769 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40770 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40771 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40772 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40773 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40774 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40775 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40776 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40777 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40778 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40779 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40780 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40781 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40782 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40783 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40784 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40785 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40786 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40787 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40788 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40789 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40790 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40791 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40792 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40793 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40794 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40795 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40796 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40797 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40798 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40799 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40800 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40801 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40802 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40803 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40804 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40805 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40806 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40807 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40808 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40809 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40810 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40811 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40812 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40813 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40814 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40815 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40816 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40817 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40818 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40819 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40820 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40821 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40822 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40823 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
40824 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40825 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40826 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40827 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40828 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40829 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40830 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40831 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40832 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40833 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40834 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40835 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40836 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40837 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40838 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40839 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40840 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40841 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40842 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40843 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40844 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40845 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40846 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40847 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40848 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40849 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40850 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40851 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40852 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40853 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40854 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40855 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40856 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40857 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40858 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40859 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40860 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40861 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40862 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40863 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40864 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40865 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40866 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40867 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40868 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40869 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40870 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40871 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40872 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40873 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40874 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40875 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40876 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40877 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40878 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40879 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40880 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40881 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40882 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40883 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40884 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40885 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40886 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40887 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40888 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40889 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40890 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40891 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40892 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40893 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40894 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40895 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40896 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40897 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40898 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40899 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40900 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40901 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40902 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40903 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40904 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40905 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40906 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40907 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40908 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40909 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40910 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40911 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40912 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40913 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40914 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40915 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40916 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40917 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40918 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40919 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40920
40921 static swig_type_info *swig_type_initial[] = {
40922 &_swigt__p_char,
40923 &_swigt__p_form_ops_t,
40924 &_swigt__p_int,
40925 &_swigt__p_unsigned_char,
40926 &_swigt__p_unsigned_int,
40927 &_swigt__p_unsigned_long,
40928 &_swigt__p_void,
40929 &_swigt__p_wxANIHandler,
40930 &_swigt__p_wxAboutDialogInfo,
40931 &_swigt__p_wxAcceleratorTable,
40932 &_swigt__p_wxActivateEvent,
40933 &_swigt__p_wxArrayString,
40934 &_swigt__p_wxBMPHandler,
40935 &_swigt__p_wxBitmap,
40936 &_swigt__p_wxBitmapDataObject,
40937 &_swigt__p_wxBoxSizer,
40938 &_swigt__p_wxBusyCursor,
40939 &_swigt__p_wxBusyInfo,
40940 &_swigt__p_wxCURHandler,
40941 &_swigt__p_wxCaret,
40942 &_swigt__p_wxChar,
40943 &_swigt__p_wxChildFocusEvent,
40944 &_swigt__p_wxClipboard,
40945 &_swigt__p_wxClipboardLocker,
40946 &_swigt__p_wxClipboardTextEvent,
40947 &_swigt__p_wxCloseEvent,
40948 &_swigt__p_wxColour,
40949 &_swigt__p_wxCommandEvent,
40950 &_swigt__p_wxConfig,
40951 &_swigt__p_wxConfigBase,
40952 &_swigt__p_wxConfigPathChanger,
40953 &_swigt__p_wxContextMenuEvent,
40954 &_swigt__p_wxControl,
40955 &_swigt__p_wxControlWithItems,
40956 &_swigt__p_wxCursor,
40957 &_swigt__p_wxCustomDataObject,
40958 &_swigt__p_wxDC,
40959 &_swigt__p_wxDataFormat,
40960 &_swigt__p_wxDataObject,
40961 &_swigt__p_wxDataObjectComposite,
40962 &_swigt__p_wxDataObjectSimple,
40963 &_swigt__p_wxDateEvent,
40964 &_swigt__p_wxDateSpan,
40965 &_swigt__p_wxDateTime,
40966 &_swigt__p_wxDateTime__TimeZone,
40967 &_swigt__p_wxDisplay,
40968 &_swigt__p_wxDisplayChangedEvent,
40969 &_swigt__p_wxDropFilesEvent,
40970 &_swigt__p_wxDuplexMode,
40971 &_swigt__p_wxEraseEvent,
40972 &_swigt__p_wxEvent,
40973 &_swigt__p_wxEventBlocker,
40974 &_swigt__p_wxEvtHandler,
40975 &_swigt__p_wxFSFile,
40976 &_swigt__p_wxFileConfig,
40977 &_swigt__p_wxFileDataObject,
40978 &_swigt__p_wxFileHistory,
40979 &_swigt__p_wxFileSystem,
40980 &_swigt__p_wxFileType,
40981 &_swigt__p_wxFileTypeInfo,
40982 &_swigt__p_wxFlexGridSizer,
40983 &_swigt__p_wxFocusEvent,
40984 &_swigt__p_wxFont,
40985 &_swigt__p_wxFrame,
40986 &_swigt__p_wxGBSizerItem,
40987 &_swigt__p_wxGIFHandler,
40988 &_swigt__p_wxGridBagSizer,
40989 &_swigt__p_wxGridSizer,
40990 &_swigt__p_wxICOHandler,
40991 &_swigt__p_wxIcon,
40992 &_swigt__p_wxIconizeEvent,
40993 &_swigt__p_wxIdleEvent,
40994 &_swigt__p_wxImage,
40995 &_swigt__p_wxImageHandler,
40996 &_swigt__p_wxIndividualLayoutConstraint,
40997 &_swigt__p_wxInitDialogEvent,
40998 &_swigt__p_wxJPEGHandler,
40999 &_swigt__p_wxJoystick,
41000 &_swigt__p_wxJoystickEvent,
41001 &_swigt__p_wxKeyEvent,
41002 &_swigt__p_wxKillError,
41003 &_swigt__p_wxLayoutConstraints,
41004 &_swigt__p_wxLog,
41005 &_swigt__p_wxLogBuffer,
41006 &_swigt__p_wxLogChain,
41007 &_swigt__p_wxLogGui,
41008 &_swigt__p_wxLogNull,
41009 &_swigt__p_wxLogStderr,
41010 &_swigt__p_wxLogTextCtrl,
41011 &_swigt__p_wxLogWindow,
41012 &_swigt__p_wxMaximizeEvent,
41013 &_swigt__p_wxMenu,
41014 &_swigt__p_wxMenuBar,
41015 &_swigt__p_wxMenuEvent,
41016 &_swigt__p_wxMenuItem,
41017 &_swigt__p_wxMetafile,
41018 &_swigt__p_wxMetafileDataObject,
41019 &_swigt__p_wxMimeTypesManager,
41020 &_swigt__p_wxMouseCaptureChangedEvent,
41021 &_swigt__p_wxMouseCaptureLostEvent,
41022 &_swigt__p_wxMouseEvent,
41023 &_swigt__p_wxMouseState,
41024 &_swigt__p_wxMoveEvent,
41025 &_swigt__p_wxMutexGuiLocker,
41026 &_swigt__p_wxNavigationKeyEvent,
41027 &_swigt__p_wxNcPaintEvent,
41028 &_swigt__p_wxNotifyEvent,
41029 &_swigt__p_wxObject,
41030 &_swigt__p_wxOutputStream,
41031 &_swigt__p_wxPCXHandler,
41032 &_swigt__p_wxPNGHandler,
41033 &_swigt__p_wxPNMHandler,
41034 &_swigt__p_wxPaintEvent,
41035 &_swigt__p_wxPaletteChangedEvent,
41036 &_swigt__p_wxPaperSize,
41037 &_swigt__p_wxPlatformInfo,
41038 &_swigt__p_wxPoint,
41039 &_swigt__p_wxPowerEvent,
41040 &_swigt__p_wxProcessEvent,
41041 &_swigt__p_wxPyApp,
41042 &_swigt__p_wxPyArtProvider,
41043 &_swigt__p_wxPyBitmapDataObject,
41044 &_swigt__p_wxPyCommandEvent,
41045 &_swigt__p_wxPyDataObjectSimple,
41046 &_swigt__p_wxPyDropSource,
41047 &_swigt__p_wxPyDropTarget,
41048 &_swigt__p_wxPyEvent,
41049 &_swigt__p_wxPyFileDropTarget,
41050 &_swigt__p_wxPyImageHandler,
41051 &_swigt__p_wxPyLog,
41052 &_swigt__p_wxPyProcess,
41053 &_swigt__p_wxPySizer,
41054 &_swigt__p_wxPyTextDataObject,
41055 &_swigt__p_wxPyTextDropTarget,
41056 &_swigt__p_wxPyTimer,
41057 &_swigt__p_wxPyTipProvider,
41058 &_swigt__p_wxPyValidator,
41059 &_swigt__p_wxQueryNewPaletteEvent,
41060 &_swigt__p_wxRect,
41061 &_swigt__p_wxScrollEvent,
41062 &_swigt__p_wxScrollWinEvent,
41063 &_swigt__p_wxSetCursorEvent,
41064 &_swigt__p_wxShowEvent,
41065 &_swigt__p_wxSingleInstanceChecker,
41066 &_swigt__p_wxSize,
41067 &_swigt__p_wxSizeEvent,
41068 &_swigt__p_wxSizer,
41069 &_swigt__p_wxSizerItem,
41070 &_swigt__p_wxSound,
41071 &_swigt__p_wxStandardPaths,
41072 &_swigt__p_wxStaticBoxSizer,
41073 &_swigt__p_wxStdDialogButtonSizer,
41074 &_swigt__p_wxStopWatch,
41075 &_swigt__p_wxString,
41076 &_swigt__p_wxSysColourChangedEvent,
41077 &_swigt__p_wxSystemOptions,
41078 &_swigt__p_wxSystemSettings,
41079 &_swigt__p_wxTGAHandler,
41080 &_swigt__p_wxTIFFHandler,
41081 &_swigt__p_wxTextCtrl,
41082 &_swigt__p_wxTextDataObject,
41083 &_swigt__p_wxTimeSpan,
41084 &_swigt__p_wxTimer,
41085 &_swigt__p_wxTimerEvent,
41086 &_swigt__p_wxTimerRunner,
41087 &_swigt__p_wxTipProvider,
41088 &_swigt__p_wxToolTip,
41089 &_swigt__p_wxURLDataObject,
41090 &_swigt__p_wxUpdateUIEvent,
41091 &_swigt__p_wxValidator,
41092 &_swigt__p_wxVideoMode,
41093 &_swigt__p_wxWindow,
41094 &_swigt__p_wxWindowCreateEvent,
41095 &_swigt__p_wxWindowDestroyEvent,
41096 &_swigt__p_wxWindowDisabler,
41097 &_swigt__p_wxXPMHandler,
41098 };
41099
41100 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41110 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}};
41111 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41119 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}};
41120 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41125 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}};
41126 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41127 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}};
41128 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41171 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}};
41172 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
41179 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_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41191 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}};
41192 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41218 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41219 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41220 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41224 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41227 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41228 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41229 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41230 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41231 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41232 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41233 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41234 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41235 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41236 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_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_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_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_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_wxXPMHandler, _p_wxXPMHandlerTo_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}};
41237 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41238 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41239 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41240 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41241 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41242 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41243 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41244 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41245 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41246 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41247 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}};
41248 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41249 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41250 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41251 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41252 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41253 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41254 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41255 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41256 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41257 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41258 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41259 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41260 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41261 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41262 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41263 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41264 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41265 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}};
41266 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41267 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41268 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41269 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41270 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}};
41271 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41272 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41273 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41274 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}};
41275 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41276
41277 static swig_cast_info *swig_cast_initial[] = {
41278 _swigc__p_char,
41279 _swigc__p_form_ops_t,
41280 _swigc__p_int,
41281 _swigc__p_unsigned_char,
41282 _swigc__p_unsigned_int,
41283 _swigc__p_unsigned_long,
41284 _swigc__p_void,
41285 _swigc__p_wxANIHandler,
41286 _swigc__p_wxAboutDialogInfo,
41287 _swigc__p_wxAcceleratorTable,
41288 _swigc__p_wxActivateEvent,
41289 _swigc__p_wxArrayString,
41290 _swigc__p_wxBMPHandler,
41291 _swigc__p_wxBitmap,
41292 _swigc__p_wxBitmapDataObject,
41293 _swigc__p_wxBoxSizer,
41294 _swigc__p_wxBusyCursor,
41295 _swigc__p_wxBusyInfo,
41296 _swigc__p_wxCURHandler,
41297 _swigc__p_wxCaret,
41298 _swigc__p_wxChar,
41299 _swigc__p_wxChildFocusEvent,
41300 _swigc__p_wxClipboard,
41301 _swigc__p_wxClipboardLocker,
41302 _swigc__p_wxClipboardTextEvent,
41303 _swigc__p_wxCloseEvent,
41304 _swigc__p_wxColour,
41305 _swigc__p_wxCommandEvent,
41306 _swigc__p_wxConfig,
41307 _swigc__p_wxConfigBase,
41308 _swigc__p_wxConfigPathChanger,
41309 _swigc__p_wxContextMenuEvent,
41310 _swigc__p_wxControl,
41311 _swigc__p_wxControlWithItems,
41312 _swigc__p_wxCursor,
41313 _swigc__p_wxCustomDataObject,
41314 _swigc__p_wxDC,
41315 _swigc__p_wxDataFormat,
41316 _swigc__p_wxDataObject,
41317 _swigc__p_wxDataObjectComposite,
41318 _swigc__p_wxDataObjectSimple,
41319 _swigc__p_wxDateEvent,
41320 _swigc__p_wxDateSpan,
41321 _swigc__p_wxDateTime,
41322 _swigc__p_wxDateTime__TimeZone,
41323 _swigc__p_wxDisplay,
41324 _swigc__p_wxDisplayChangedEvent,
41325 _swigc__p_wxDropFilesEvent,
41326 _swigc__p_wxDuplexMode,
41327 _swigc__p_wxEraseEvent,
41328 _swigc__p_wxEvent,
41329 _swigc__p_wxEventBlocker,
41330 _swigc__p_wxEvtHandler,
41331 _swigc__p_wxFSFile,
41332 _swigc__p_wxFileConfig,
41333 _swigc__p_wxFileDataObject,
41334 _swigc__p_wxFileHistory,
41335 _swigc__p_wxFileSystem,
41336 _swigc__p_wxFileType,
41337 _swigc__p_wxFileTypeInfo,
41338 _swigc__p_wxFlexGridSizer,
41339 _swigc__p_wxFocusEvent,
41340 _swigc__p_wxFont,
41341 _swigc__p_wxFrame,
41342 _swigc__p_wxGBSizerItem,
41343 _swigc__p_wxGIFHandler,
41344 _swigc__p_wxGridBagSizer,
41345 _swigc__p_wxGridSizer,
41346 _swigc__p_wxICOHandler,
41347 _swigc__p_wxIcon,
41348 _swigc__p_wxIconizeEvent,
41349 _swigc__p_wxIdleEvent,
41350 _swigc__p_wxImage,
41351 _swigc__p_wxImageHandler,
41352 _swigc__p_wxIndividualLayoutConstraint,
41353 _swigc__p_wxInitDialogEvent,
41354 _swigc__p_wxJPEGHandler,
41355 _swigc__p_wxJoystick,
41356 _swigc__p_wxJoystickEvent,
41357 _swigc__p_wxKeyEvent,
41358 _swigc__p_wxKillError,
41359 _swigc__p_wxLayoutConstraints,
41360 _swigc__p_wxLog,
41361 _swigc__p_wxLogBuffer,
41362 _swigc__p_wxLogChain,
41363 _swigc__p_wxLogGui,
41364 _swigc__p_wxLogNull,
41365 _swigc__p_wxLogStderr,
41366 _swigc__p_wxLogTextCtrl,
41367 _swigc__p_wxLogWindow,
41368 _swigc__p_wxMaximizeEvent,
41369 _swigc__p_wxMenu,
41370 _swigc__p_wxMenuBar,
41371 _swigc__p_wxMenuEvent,
41372 _swigc__p_wxMenuItem,
41373 _swigc__p_wxMetafile,
41374 _swigc__p_wxMetafileDataObject,
41375 _swigc__p_wxMimeTypesManager,
41376 _swigc__p_wxMouseCaptureChangedEvent,
41377 _swigc__p_wxMouseCaptureLostEvent,
41378 _swigc__p_wxMouseEvent,
41379 _swigc__p_wxMouseState,
41380 _swigc__p_wxMoveEvent,
41381 _swigc__p_wxMutexGuiLocker,
41382 _swigc__p_wxNavigationKeyEvent,
41383 _swigc__p_wxNcPaintEvent,
41384 _swigc__p_wxNotifyEvent,
41385 _swigc__p_wxObject,
41386 _swigc__p_wxOutputStream,
41387 _swigc__p_wxPCXHandler,
41388 _swigc__p_wxPNGHandler,
41389 _swigc__p_wxPNMHandler,
41390 _swigc__p_wxPaintEvent,
41391 _swigc__p_wxPaletteChangedEvent,
41392 _swigc__p_wxPaperSize,
41393 _swigc__p_wxPlatformInfo,
41394 _swigc__p_wxPoint,
41395 _swigc__p_wxPowerEvent,
41396 _swigc__p_wxProcessEvent,
41397 _swigc__p_wxPyApp,
41398 _swigc__p_wxPyArtProvider,
41399 _swigc__p_wxPyBitmapDataObject,
41400 _swigc__p_wxPyCommandEvent,
41401 _swigc__p_wxPyDataObjectSimple,
41402 _swigc__p_wxPyDropSource,
41403 _swigc__p_wxPyDropTarget,
41404 _swigc__p_wxPyEvent,
41405 _swigc__p_wxPyFileDropTarget,
41406 _swigc__p_wxPyImageHandler,
41407 _swigc__p_wxPyLog,
41408 _swigc__p_wxPyProcess,
41409 _swigc__p_wxPySizer,
41410 _swigc__p_wxPyTextDataObject,
41411 _swigc__p_wxPyTextDropTarget,
41412 _swigc__p_wxPyTimer,
41413 _swigc__p_wxPyTipProvider,
41414 _swigc__p_wxPyValidator,
41415 _swigc__p_wxQueryNewPaletteEvent,
41416 _swigc__p_wxRect,
41417 _swigc__p_wxScrollEvent,
41418 _swigc__p_wxScrollWinEvent,
41419 _swigc__p_wxSetCursorEvent,
41420 _swigc__p_wxShowEvent,
41421 _swigc__p_wxSingleInstanceChecker,
41422 _swigc__p_wxSize,
41423 _swigc__p_wxSizeEvent,
41424 _swigc__p_wxSizer,
41425 _swigc__p_wxSizerItem,
41426 _swigc__p_wxSound,
41427 _swigc__p_wxStandardPaths,
41428 _swigc__p_wxStaticBoxSizer,
41429 _swigc__p_wxStdDialogButtonSizer,
41430 _swigc__p_wxStopWatch,
41431 _swigc__p_wxString,
41432 _swigc__p_wxSysColourChangedEvent,
41433 _swigc__p_wxSystemOptions,
41434 _swigc__p_wxSystemSettings,
41435 _swigc__p_wxTGAHandler,
41436 _swigc__p_wxTIFFHandler,
41437 _swigc__p_wxTextCtrl,
41438 _swigc__p_wxTextDataObject,
41439 _swigc__p_wxTimeSpan,
41440 _swigc__p_wxTimer,
41441 _swigc__p_wxTimerEvent,
41442 _swigc__p_wxTimerRunner,
41443 _swigc__p_wxTipProvider,
41444 _swigc__p_wxToolTip,
41445 _swigc__p_wxURLDataObject,
41446 _swigc__p_wxUpdateUIEvent,
41447 _swigc__p_wxValidator,
41448 _swigc__p_wxVideoMode,
41449 _swigc__p_wxWindow,
41450 _swigc__p_wxWindowCreateEvent,
41451 _swigc__p_wxWindowDestroyEvent,
41452 _swigc__p_wxWindowDisabler,
41453 _swigc__p_wxXPMHandler,
41454 };
41455
41456
41457 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41458
41459 static swig_const_info swig_const_table[] = {
41460 {0, 0, 0, 0.0, 0, 0}};
41461
41462 #ifdef __cplusplus
41463 }
41464 #endif
41465 /* -----------------------------------------------------------------------------
41466 * Type initialization:
41467 * This problem is tough by the requirement that no dynamic
41468 * memory is used. Also, since swig_type_info structures store pointers to
41469 * swig_cast_info structures and swig_cast_info structures store pointers back
41470 * to swig_type_info structures, we need some lookup code at initialization.
41471 * The idea is that swig generates all the structures that are needed.
41472 * The runtime then collects these partially filled structures.
41473 * The SWIG_InitializeModule function takes these initial arrays out of
41474 * swig_module, and does all the lookup, filling in the swig_module.types
41475 * array with the correct data and linking the correct swig_cast_info
41476 * structures together.
41477 *
41478 * The generated swig_type_info structures are assigned staticly to an initial
41479 * array. We just loop though that array, and handle each type individually.
41480 * First we lookup if this type has been already loaded, and if so, use the
41481 * loaded structure instead of the generated one. Then we have to fill in the
41482 * cast linked list. The cast data is initially stored in something like a
41483 * two-dimensional array. Each row corresponds to a type (there are the same
41484 * number of rows as there are in the swig_type_initial array). Each entry in
41485 * a column is one of the swig_cast_info structures for that type.
41486 * The cast_initial array is actually an array of arrays, because each row has
41487 * a variable number of columns. So to actually build the cast linked list,
41488 * we find the array of casts associated with the type, and loop through it
41489 * adding the casts to the list. The one last trick we need to do is making
41490 * sure the type pointer in the swig_cast_info struct is correct.
41491 *
41492 * First off, we lookup the cast->type name to see if it is already loaded.
41493 * There are three cases to handle:
41494 * 1) If the cast->type has already been loaded AND the type we are adding
41495 * casting info to has not been loaded (it is in this module), THEN we
41496 * replace the cast->type pointer with the type pointer that has already
41497 * been loaded.
41498 * 2) If BOTH types (the one we are adding casting info to, and the
41499 * cast->type) are loaded, THEN the cast info has already been loaded by
41500 * the previous module so we just ignore it.
41501 * 3) Finally, if cast->type has not already been loaded, then we add that
41502 * swig_cast_info to the linked list (because the cast->type) pointer will
41503 * be correct.
41504 * ----------------------------------------------------------------------------- */
41505
41506 #ifdef __cplusplus
41507 extern "C" {
41508 #if 0
41509 } /* c-mode */
41510 #endif
41511 #endif
41512
41513 #if 0
41514 #define SWIGRUNTIME_DEBUG
41515 #endif
41516
41517 SWIGRUNTIME void
41518 SWIG_InitializeModule(void *clientdata) {
41519 size_t i;
41520 swig_module_info *module_head;
41521 static int init_run = 0;
41522
41523 clientdata = clientdata;
41524
41525 if (init_run) return;
41526 init_run = 1;
41527
41528 /* Initialize the swig_module */
41529 swig_module.type_initial = swig_type_initial;
41530 swig_module.cast_initial = swig_cast_initial;
41531
41532 /* Try and load any already created modules */
41533 module_head = SWIG_GetModule(clientdata);
41534 if (module_head) {
41535 swig_module.next = module_head->next;
41536 module_head->next = &swig_module;
41537 } else {
41538 /* This is the first module loaded */
41539 swig_module.next = &swig_module;
41540 SWIG_SetModule(clientdata, &swig_module);
41541 }
41542
41543 /* Now work on filling in swig_module.types */
41544 #ifdef SWIGRUNTIME_DEBUG
41545 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41546 #endif
41547 for (i = 0; i < swig_module.size; ++i) {
41548 swig_type_info *type = 0;
41549 swig_type_info *ret;
41550 swig_cast_info *cast;
41551
41552 #ifdef SWIGRUNTIME_DEBUG
41553 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41554 #endif
41555
41556 /* if there is another module already loaded */
41557 if (swig_module.next != &swig_module) {
41558 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41559 }
41560 if (type) {
41561 /* Overwrite clientdata field */
41562 #ifdef SWIGRUNTIME_DEBUG
41563 printf("SWIG_InitializeModule: found type %s\n", type->name);
41564 #endif
41565 if (swig_module.type_initial[i]->clientdata) {
41566 type->clientdata = swig_module.type_initial[i]->clientdata;
41567 #ifdef SWIGRUNTIME_DEBUG
41568 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41569 #endif
41570 }
41571 } else {
41572 type = swig_module.type_initial[i];
41573 }
41574
41575 /* Insert casting types */
41576 cast = swig_module.cast_initial[i];
41577 while (cast->type) {
41578 /* Don't need to add information already in the list */
41579 ret = 0;
41580 #ifdef SWIGRUNTIME_DEBUG
41581 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41582 #endif
41583 if (swig_module.next != &swig_module) {
41584 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41585 #ifdef SWIGRUNTIME_DEBUG
41586 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41587 #endif
41588 }
41589 if (ret) {
41590 if (type == swig_module.type_initial[i]) {
41591 #ifdef SWIGRUNTIME_DEBUG
41592 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41593 #endif
41594 cast->type = ret;
41595 ret = 0;
41596 } else {
41597 /* Check for casting already in the list */
41598 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41599 #ifdef SWIGRUNTIME_DEBUG
41600 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41601 #endif
41602 if (!ocast) ret = 0;
41603 }
41604 }
41605
41606 if (!ret) {
41607 #ifdef SWIGRUNTIME_DEBUG
41608 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41609 #endif
41610 if (type->cast) {
41611 type->cast->prev = cast;
41612 cast->next = type->cast;
41613 }
41614 type->cast = cast;
41615 }
41616 cast++;
41617 }
41618 /* Set entry in modules->types array equal to the type */
41619 swig_module.types[i] = type;
41620 }
41621 swig_module.types[i] = 0;
41622
41623 #ifdef SWIGRUNTIME_DEBUG
41624 printf("**** SWIG_InitializeModule: Cast List ******\n");
41625 for (i = 0; i < swig_module.size; ++i) {
41626 int j = 0;
41627 swig_cast_info *cast = swig_module.cast_initial[i];
41628 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41629 while (cast->type) {
41630 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41631 cast++;
41632 ++j;
41633 }
41634 printf("---- Total casts: %d\n",j);
41635 }
41636 printf("**** SWIG_InitializeModule: Cast List ******\n");
41637 #endif
41638 }
41639
41640 /* This function will propagate the clientdata field of type to
41641 * any new swig_type_info structures that have been added into the list
41642 * of equivalent types. It is like calling
41643 * SWIG_TypeClientData(type, clientdata) a second time.
41644 */
41645 SWIGRUNTIME void
41646 SWIG_PropagateClientData(void) {
41647 size_t i;
41648 swig_cast_info *equiv;
41649 static int init_run = 0;
41650
41651 if (init_run) return;
41652 init_run = 1;
41653
41654 for (i = 0; i < swig_module.size; i++) {
41655 if (swig_module.types[i]->clientdata) {
41656 equiv = swig_module.types[i]->cast;
41657 while (equiv) {
41658 if (!equiv->converter) {
41659 if (equiv->type && !equiv->type->clientdata)
41660 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41661 }
41662 equiv = equiv->next;
41663 }
41664 }
41665 }
41666 }
41667
41668 #ifdef __cplusplus
41669 #if 0
41670 {
41671 /* c-mode */
41672 #endif
41673 }
41674 #endif
41675
41676
41677
41678 #ifdef __cplusplus
41679 extern "C" {
41680 #endif
41681
41682 /* Python-specific SWIG API */
41683 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41684 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41685 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41686
41687 /* -----------------------------------------------------------------------------
41688 * global variable support code.
41689 * ----------------------------------------------------------------------------- */
41690
41691 typedef struct swig_globalvar {
41692 char *name; /* Name of global variable */
41693 PyObject *(*get_attr)(void); /* Return the current value */
41694 int (*set_attr)(PyObject *); /* Set the value */
41695 struct swig_globalvar *next;
41696 } swig_globalvar;
41697
41698 typedef struct swig_varlinkobject {
41699 PyObject_HEAD
41700 swig_globalvar *vars;
41701 } swig_varlinkobject;
41702
41703 SWIGINTERN PyObject *
41704 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41705 return PyString_FromString("<Swig global variables>");
41706 }
41707
41708 SWIGINTERN PyObject *
41709 swig_varlink_str(swig_varlinkobject *v) {
41710 PyObject *str = PyString_FromString("(");
41711 swig_globalvar *var;
41712 for (var = v->vars; var; var=var->next) {
41713 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41714 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41715 }
41716 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41717 return str;
41718 }
41719
41720 SWIGINTERN int
41721 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41722 PyObject *str = swig_varlink_str(v);
41723 fprintf(fp,"Swig global variables ");
41724 fprintf(fp,"%s\n", PyString_AsString(str));
41725 Py_DECREF(str);
41726 return 0;
41727 }
41728
41729 SWIGINTERN void
41730 swig_varlink_dealloc(swig_varlinkobject *v) {
41731 swig_globalvar *var = v->vars;
41732 while (var) {
41733 swig_globalvar *n = var->next;
41734 free(var->name);
41735 free(var);
41736 var = n;
41737 }
41738 }
41739
41740 SWIGINTERN PyObject *
41741 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41742 PyObject *res = NULL;
41743 swig_globalvar *var = v->vars;
41744 while (var) {
41745 if (strcmp(var->name,n) == 0) {
41746 res = (*var->get_attr)();
41747 break;
41748 }
41749 var = var->next;
41750 }
41751 if (res == NULL && !PyErr_Occurred()) {
41752 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41753 }
41754 return res;
41755 }
41756
41757 SWIGINTERN int
41758 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41759 int res = 1;
41760 swig_globalvar *var = v->vars;
41761 while (var) {
41762 if (strcmp(var->name,n) == 0) {
41763 res = (*var->set_attr)(p);
41764 break;
41765 }
41766 var = var->next;
41767 }
41768 if (res == 1 && !PyErr_Occurred()) {
41769 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41770 }
41771 return res;
41772 }
41773
41774 SWIGINTERN PyTypeObject*
41775 swig_varlink_type(void) {
41776 static char varlink__doc__[] = "Swig var link object";
41777 static PyTypeObject varlink_type;
41778 static int type_init = 0;
41779 if (!type_init) {
41780 const PyTypeObject tmp
41781 = {
41782 PyObject_HEAD_INIT(NULL)
41783 0, /* Number of items in variable part (ob_size) */
41784 (char *)"swigvarlink", /* Type name (tp_name) */
41785 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41786 0, /* Itemsize (tp_itemsize) */
41787 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41788 (printfunc) swig_varlink_print, /* Print (tp_print) */
41789 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41790 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41791 0, /* tp_compare */
41792 (reprfunc) swig_varlink_repr, /* tp_repr */
41793 0, /* tp_as_number */
41794 0, /* tp_as_sequence */
41795 0, /* tp_as_mapping */
41796 0, /* tp_hash */
41797 0, /* tp_call */
41798 (reprfunc)swig_varlink_str, /* tp_str */
41799 0, /* tp_getattro */
41800 0, /* tp_setattro */
41801 0, /* tp_as_buffer */
41802 0, /* tp_flags */
41803 varlink__doc__, /* tp_doc */
41804 0, /* tp_traverse */
41805 0, /* tp_clear */
41806 0, /* tp_richcompare */
41807 0, /* tp_weaklistoffset */
41808 #if PY_VERSION_HEX >= 0x02020000
41809 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41810 #endif
41811 #if PY_VERSION_HEX >= 0x02030000
41812 0, /* tp_del */
41813 #endif
41814 #ifdef COUNT_ALLOCS
41815 0,0,0,0 /* tp_alloc -> tp_next */
41816 #endif
41817 };
41818 varlink_type = tmp;
41819 varlink_type.ob_type = &PyType_Type;
41820 type_init = 1;
41821 }
41822 return &varlink_type;
41823 }
41824
41825 /* Create a variable linking object for use later */
41826 SWIGINTERN PyObject *
41827 SWIG_Python_newvarlink(void) {
41828 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41829 if (result) {
41830 result->vars = 0;
41831 }
41832 return ((PyObject*) result);
41833 }
41834
41835 SWIGINTERN void
41836 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41837 swig_varlinkobject *v = (swig_varlinkobject *) p;
41838 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41839 if (gv) {
41840 size_t size = strlen(name)+1;
41841 gv->name = (char *)malloc(size);
41842 if (gv->name) {
41843 strncpy(gv->name,name,size);
41844 gv->get_attr = get_attr;
41845 gv->set_attr = set_attr;
41846 gv->next = v->vars;
41847 }
41848 }
41849 v->vars = gv;
41850 }
41851
41852 SWIGINTERN PyObject *
41853 SWIG_globals() {
41854 static PyObject *_SWIG_globals = 0;
41855 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41856 return _SWIG_globals;
41857 }
41858
41859 /* -----------------------------------------------------------------------------
41860 * constants/methods manipulation
41861 * ----------------------------------------------------------------------------- */
41862
41863 /* Install Constants */
41864 SWIGINTERN void
41865 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41866 PyObject *obj = 0;
41867 size_t i;
41868 for (i = 0; constants[i].type; ++i) {
41869 switch(constants[i].type) {
41870 case SWIG_PY_POINTER:
41871 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41872 break;
41873 case SWIG_PY_BINARY:
41874 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41875 break;
41876 default:
41877 obj = 0;
41878 break;
41879 }
41880 if (obj) {
41881 PyDict_SetItemString(d, constants[i].name, obj);
41882 Py_DECREF(obj);
41883 }
41884 }
41885 }
41886
41887 /* -----------------------------------------------------------------------------*/
41888 /* Fix SwigMethods to carry the callback ptrs when needed */
41889 /* -----------------------------------------------------------------------------*/
41890
41891 SWIGINTERN void
41892 SWIG_Python_FixMethods(PyMethodDef *methods,
41893 swig_const_info *const_table,
41894 swig_type_info **types,
41895 swig_type_info **types_initial) {
41896 size_t i;
41897 for (i = 0; methods[i].ml_name; ++i) {
41898 const char *c = methods[i].ml_doc;
41899 if (c && (c = strstr(c, "swig_ptr: "))) {
41900 int j;
41901 swig_const_info *ci = 0;
41902 const char *name = c + 10;
41903 for (j = 0; const_table[j].type; ++j) {
41904 if (strncmp(const_table[j].name, name,
41905 strlen(const_table[j].name)) == 0) {
41906 ci = &(const_table[j]);
41907 break;
41908 }
41909 }
41910 if (ci) {
41911 size_t shift = (ci->ptype) - types;
41912 swig_type_info *ty = types_initial[shift];
41913 size_t ldoc = (c - methods[i].ml_doc);
41914 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41915 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41916 if (ndoc) {
41917 char *buff = ndoc;
41918 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41919 if (ptr) {
41920 strncpy(buff, methods[i].ml_doc, ldoc);
41921 buff += ldoc;
41922 strncpy(buff, "swig_ptr: ", 10);
41923 buff += 10;
41924 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41925 methods[i].ml_doc = ndoc;
41926 }
41927 }
41928 }
41929 }
41930 }
41931 }
41932
41933 #ifdef __cplusplus
41934 }
41935 #endif
41936
41937 /* -----------------------------------------------------------------------------*
41938 * Partial Init method
41939 * -----------------------------------------------------------------------------*/
41940
41941 #ifdef __cplusplus
41942 extern "C"
41943 #endif
41944 SWIGEXPORT void SWIG_init(void) {
41945 PyObject *m, *d;
41946
41947 /* Fix SwigMethods to carry the callback ptrs when needed */
41948 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41949
41950 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41951 d = PyModule_GetDict(m);
41952
41953 SWIG_InitializeModule(0);
41954 SWIG_InstallConstants(d,swig_const_table);
41955
41956
41957 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41958 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41959 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41960 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41961 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41962 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41963 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41964 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41965 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41966 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41967 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41968 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41969 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41970 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41971 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41972 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41973 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41974 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41975 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41976 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41977 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41978 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41979 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41980 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41981 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41982 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41983 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41984 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41985 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41986 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41987 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41988 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41989 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41990 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41991 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41992 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41993 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41994 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41995 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41996 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41997 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41998 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41999 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
42000 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
42001 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
42002 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
42003 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
42004 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
42005 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
42006 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
42007 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
42008 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
42009 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
42010 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
42011 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
42012 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
42013 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
42014 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
42015 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
42016 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
42017 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
42018 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
42019 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
42020 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
42021 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
42022 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
42023 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
42024 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
42025 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
42026 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
42027 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
42028 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
42029 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
42030 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
42031 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
42032 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
42033 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
42034 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
42035 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
42036 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
42037 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
42038 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
42039 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
42040 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
42041 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
42042 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
42043 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
42044 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
42045 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
42046 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42047 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42048 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42049 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42050 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42051 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42052 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42053 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42054 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42055 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42056 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42057 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42058 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42059 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42060 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42061 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42062 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42063 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42064 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42065 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42066 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42067 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42068 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42069 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42070 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42071 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42072 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42073 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42074 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42075 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42076 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42077 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42078 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42079 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42080 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42081 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42082 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42083 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42084 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42085 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42086 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42087 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42088 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42089 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42090 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42091 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42092 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42093 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42094 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42095 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42096 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42097 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42098 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42099 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42100 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42101 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42102 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42103 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42104 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42105
42106 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42107
42108 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42109 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42110 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42111 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42112 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42113 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42114 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42115 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42116 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42117 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42118 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42119 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42120 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42121 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42122 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42123 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42124 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42125 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42126 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42127 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42128 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42129 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42130 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42131 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42132 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42133 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42134 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42135 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42136 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42137 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42138 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42139 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42140 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42141 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42142 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42143 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42144 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42145 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42146 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42147 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42148 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42149 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42150 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42151 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42152 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42153 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42154 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42155 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42156 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42157 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42158 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42159 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42160 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42161
42162 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42163
42164 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42165 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42166 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42167 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42168 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42169 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42170 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42171 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42172 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42173 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42174 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42175 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42176 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42177 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42178 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42179 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42180 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42181 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42182 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42183 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42190 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42191 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42192 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42193 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42194 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42195 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42196 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42197 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42198 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42199 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42200 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42201 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42202 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42203 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42204 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42205 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42206 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42207 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42208 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42209 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42210 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42211 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42212 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42213 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42214 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42215 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42216 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42217 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42218 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42219 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42220 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42221 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42222 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42223 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42224 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42225 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42226 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42227 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42228 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42229 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42230 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42231 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42232 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42233 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42234 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42235 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42236 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42237 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42238 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42239 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42240
42241 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42242
42243 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42244 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42245 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42246 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42247 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42248 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42249 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42250 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42251 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42252 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42253 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42254 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42255 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42256 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42257 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42258 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42259 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42260 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42261 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42262 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42263 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42264 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42265 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42266 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42267 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42268 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42269 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42270 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42271 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42272 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42273 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42274 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42275 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42276 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42277 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42278 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42279 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42280 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42281 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42282 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42283 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42284 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42285 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42286 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42287 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42288 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42289 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42290 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42291 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42292 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42293 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42294 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42295 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42296 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42297 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42298 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42299 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42300 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42301 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42302 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42303 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42304 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42305 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42306 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42307 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42308 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42309 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42310 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42311 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42312 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42313 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42314 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42315 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42316 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42317 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42318 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42319 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42320 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42321 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42322 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42323 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42324 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42325 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42326 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42327 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42328 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42329 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42330 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42331 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42332 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42333 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42334 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42335 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42336 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42337 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42338 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42339 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42340 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42341 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42342 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42343 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42344 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42345 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42346 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42347 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42348 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42349 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42350 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42351 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42352 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42353 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42354 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42355 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42356 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42357 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42358 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42359 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42360 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42361 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42362 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42363 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42364 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42365 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42366 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42367 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42368 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42369 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42370 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42371 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42372 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42373 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42374 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42375 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42376 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42377 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42378 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42379 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42380 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42381 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42382 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42383 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42384 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42385 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42386 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42387 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42388 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42389 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42390 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42391 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42392 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42393 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42394 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42395 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42396 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42397 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42398 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42399 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42400 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42401 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42402 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42403 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42404 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42405 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42406 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42407 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42408 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42409 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42410 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42411 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42412 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42413 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42414 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42415 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42416 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42417 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42418 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42419 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42420 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42421 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42422 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42423 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42424 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42425 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42426 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42427 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42428 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42429 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42430 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42431 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42432 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42433 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42434 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42435 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42436 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42437 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42438 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42439 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42440 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42441 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42442 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42443 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42444 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42445 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42446
42447 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42448 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42449 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42450 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42451
42452 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42453 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42454 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42455 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42456 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42457 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42458 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42459 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42460 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42461 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42462 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42463 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42464 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42465 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42466 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42467 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42468 }
42469
wxWidgets (Impactor)