]> 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
use common AllocExclusive, rather than custom code
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAboutDialogInfo swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorTable swig_types[9]
2476 #define SWIGTYPE_p_wxActivateEvent swig_types[10]
2477 #define SWIGTYPE_p_wxArrayString swig_types[11]
2478 #define SWIGTYPE_p_wxBMPHandler swig_types[12]
2479 #define SWIGTYPE_p_wxBitmap swig_types[13]
2480 #define SWIGTYPE_p_wxBitmapDataObject swig_types[14]
2481 #define SWIGTYPE_p_wxBoxSizer swig_types[15]
2482 #define SWIGTYPE_p_wxBusyCursor swig_types[16]
2483 #define SWIGTYPE_p_wxBusyInfo swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChar swig_types[20]
2487 #define SWIGTYPE_p_wxChildFocusEvent swig_types[21]
2488 #define SWIGTYPE_p_wxClipboard swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
2490 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[24]
2491 #define SWIGTYPE_p_wxCloseEvent swig_types[25]
2492 #define SWIGTYPE_p_wxColour swig_types[26]
2493 #define SWIGTYPE_p_wxCommandEvent swig_types[27]
2494 #define SWIGTYPE_p_wxConfig swig_types[28]
2495 #define SWIGTYPE_p_wxConfigBase swig_types[29]
2496 #define SWIGTYPE_p_wxConfigPathChanger swig_types[30]
2497 #define SWIGTYPE_p_wxContextMenuEvent swig_types[31]
2498 #define SWIGTYPE_p_wxControl swig_types[32]
2499 #define SWIGTYPE_p_wxControlWithItems swig_types[33]
2500 #define SWIGTYPE_p_wxCursor swig_types[34]
2501 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
2502 #define SWIGTYPE_p_wxDC swig_types[36]
2503 #define SWIGTYPE_p_wxDataFormat swig_types[37]
2504 #define SWIGTYPE_p_wxDataObject swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectComposite swig_types[39]
2506 #define SWIGTYPE_p_wxDataObjectSimple swig_types[40]
2507 #define SWIGTYPE_p_wxDateEvent swig_types[41]
2508 #define SWIGTYPE_p_wxDateSpan swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime swig_types[43]
2510 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[44]
2511 #define SWIGTYPE_p_wxDisplay swig_types[45]
2512 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDropFilesEvent swig_types[47]
2514 #define SWIGTYPE_p_wxDuplexMode swig_types[48]
2515 #define SWIGTYPE_p_wxEraseEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvent swig_types[50]
2517 #define SWIGTYPE_p_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafile swig_types[94]
2561 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2562 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMouseState swig_types[100]
2567 #define SWIGTYPE_p_wxMoveEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[102]
2569 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNcPaintEvent swig_types[104]
2571 #define SWIGTYPE_p_wxNotifyEvent swig_types[105]
2572 #define SWIGTYPE_p_wxObject swig_types[106]
2573 #define SWIGTYPE_p_wxOutputStream swig_types[107]
2574 #define SWIGTYPE_p_wxPCXHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNGHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPNMHandler swig_types[110]
2577 #define SWIGTYPE_p_wxPaintEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[112]
2579 #define SWIGTYPE_p_wxPaperSize swig_types[113]
2580 #define SWIGTYPE_p_wxPlatformInfo swig_types[114]
2581 #define SWIGTYPE_p_wxPoint swig_types[115]
2582 #define SWIGTYPE_p_wxPowerEvent swig_types[116]
2583 #define SWIGTYPE_p_wxProcessEvent swig_types[117]
2584 #define SWIGTYPE_p_wxPyApp swig_types[118]
2585 #define SWIGTYPE_p_wxPyArtProvider swig_types[119]
2586 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[120]
2587 #define SWIGTYPE_p_wxPyCommandEvent swig_types[121]
2588 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropSource swig_types[123]
2590 #define SWIGTYPE_p_wxPyDropTarget swig_types[124]
2591 #define SWIGTYPE_p_wxPyEvent swig_types[125]
2592 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[126]
2593 #define SWIGTYPE_p_wxPyImageHandler swig_types[127]
2594 #define SWIGTYPE_p_wxPyLog swig_types[128]
2595 #define SWIGTYPE_p_wxPyProcess swig_types[129]
2596 #define SWIGTYPE_p_wxPySizer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDataObject swig_types[131]
2598 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[132]
2599 #define SWIGTYPE_p_wxPyTimer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTipProvider swig_types[134]
2601 #define SWIGTYPE_p_wxPyValidator swig_types[135]
2602 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[136]
2603 #define SWIGTYPE_p_wxRect swig_types[137]
2604 #define SWIGTYPE_p_wxScrollEvent swig_types[138]
2605 #define SWIGTYPE_p_wxScrollWinEvent swig_types[139]
2606 #define SWIGTYPE_p_wxSetCursorEvent swig_types[140]
2607 #define SWIGTYPE_p_wxShowEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[142]
2609 #define SWIGTYPE_p_wxSize swig_types[143]
2610 #define SWIGTYPE_p_wxSizeEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSizer swig_types[145]
2612 #define SWIGTYPE_p_wxSizerItem swig_types[146]
2613 #define SWIGTYPE_p_wxSound swig_types[147]
2614 #define SWIGTYPE_p_wxStandardPaths swig_types[148]
2615 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[150]
2617 #define SWIGTYPE_p_wxStopWatch swig_types[151]
2618 #define SWIGTYPE_p_wxString swig_types[152]
2619 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[153]
2620 #define SWIGTYPE_p_wxSystemOptions swig_types[154]
2621 #define SWIGTYPE_p_wxSystemSettings swig_types[155]
2622 #define SWIGTYPE_p_wxTIFFHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTextCtrl swig_types[157]
2624 #define SWIGTYPE_p_wxTextDataObject swig_types[158]
2625 #define SWIGTYPE_p_wxTimeSpan swig_types[159]
2626 #define SWIGTYPE_p_wxTimer swig_types[160]
2627 #define SWIGTYPE_p_wxTimerEvent swig_types[161]
2628 #define SWIGTYPE_p_wxTimerRunner swig_types[162]
2629 #define SWIGTYPE_p_wxTipProvider swig_types[163]
2630 #define SWIGTYPE_p_wxToolTip swig_types[164]
2631 #define SWIGTYPE_p_wxURLDataObject swig_types[165]
2632 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[166]
2633 #define SWIGTYPE_p_wxValidator swig_types[167]
2634 #define SWIGTYPE_p_wxVideoMode swig_types[168]
2635 #define SWIGTYPE_p_wxWindow swig_types[169]
2636 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDisabler swig_types[172]
2639 #define SWIGTYPE_p_wxXPMHandler swig_types[173]
2640 static swig_type_info *swig_types[175];
2641 static swig_module_info swig_module = {swig_types, 174, 0, 0, 0, 0};
2642 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2643 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2644
2645 /* -------- TYPES TABLE (END) -------- */
2646
2647 #if (PY_VERSION_HEX <= 0x02000000)
2648 # if !defined(SWIG_PYTHON_CLASSIC)
2649 # error "This python version requires to use swig with the '-classic' option"
2650 # endif
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodern' option"
2654 #endif
2655 #if (PY_VERSION_HEX <= 0x02020000)
2656 # error "This python version requires to use swig with the '-nomodernargs' option"
2657 #endif
2658 #ifndef METH_O
2659 # error "This python version requires to use swig with the '-nofastunpack' option"
2660 #endif
2661
2662 /*-----------------------------------------------
2663 @(target):= _misc_.so
2664 ------------------------------------------------*/
2665 #define SWIG_init init_misc_
2666
2667 #define SWIG_name "_misc_"
2668
2669 #define SWIGVERSION 0x010329
2670
2671
2672 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2673 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2674
2675
2676 #include <stdexcept>
2677
2678
2679 namespace swig {
2680 class PyObject_ptr {
2681 protected:
2682 PyObject *_obj;
2683
2684 public:
2685 PyObject_ptr() :_obj(0)
2686 {
2687 }
2688
2689 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2690 {
2691 Py_XINCREF(_obj);
2692 }
2693
2694 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2695 {
2696 if (initial_ref) Py_XINCREF(_obj);
2697 }
2698
2699 PyObject_ptr & operator=(const PyObject_ptr& item)
2700 {
2701 Py_XINCREF(item._obj);
2702 Py_XDECREF(_obj);
2703 _obj = item._obj;
2704 return *this;
2705 }
2706
2707 ~PyObject_ptr()
2708 {
2709 Py_XDECREF(_obj);
2710 }
2711
2712 operator PyObject *() const
2713 {
2714 return _obj;
2715 }
2716
2717 PyObject *operator->() const
2718 {
2719 return _obj;
2720 }
2721 };
2722 }
2723
2724
2725 namespace swig {
2726 struct PyObject_var : PyObject_ptr {
2727 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2728
2729 PyObject_var & operator = (PyObject* obj)
2730 {
2731 Py_XDECREF(_obj);
2732 _obj = obj;
2733 return *this;
2734 }
2735 };
2736 }
2737
2738
2739 #include "wx/wxPython/wxPython.h"
2740 #include "wx/wxPython/pyclasses.h"
2741 #include "wx/wxPython/pyistream.h"
2742
2743 static const wxString wxPyEmptyString(wxEmptyString);
2744
2745
2746
2747 #define SWIG_From_long PyInt_FromLong
2748
2749
2750 SWIGINTERNINLINE PyObject *
2751 SWIG_From_int (int value)
2752 {
2753 return SWIG_From_long (value);
2754 }
2755
2756
2757 #include <limits.h>
2758 #ifndef LLONG_MIN
2759 # define LLONG_MIN LONG_LONG_MIN
2760 #endif
2761 #ifndef LLONG_MAX
2762 # define LLONG_MAX LONG_LONG_MAX
2763 #endif
2764 #ifndef ULLONG_MAX
2765 # define ULLONG_MAX ULONG_LONG_MAX
2766 #endif
2767
2768
2769 SWIGINTERN int
2770 SWIG_AsVal_long (PyObject* obj, long* val)
2771 {
2772 if (PyNumber_Check(obj)) {
2773 if (val) *val = PyInt_AsLong(obj);
2774 return SWIG_OK;
2775 }
2776 return SWIG_TypeError;
2777 }
2778
2779
2780 SWIGINTERN int
2781 SWIG_AsVal_int (PyObject * obj, int *val)
2782 {
2783 long v;
2784 int res = SWIG_AsVal_long (obj, &v);
2785 if (SWIG_IsOK(res)) {
2786 if ((v < INT_MIN || v > INT_MAX)) {
2787 return SWIG_OverflowError;
2788 } else {
2789 if (val) *val = static_cast< int >(v);
2790 }
2791 }
2792 return res;
2793 }
2794
2795 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2796
2797 #include <wx/stockitem.h>
2798
2799 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2800 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2801 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2802
2803 SWIGINTERN int
2804 SWIG_AsVal_bool (PyObject *obj, bool *val)
2805 {
2806 if (obj == Py_True) {
2807 if (val) *val = true;
2808 return SWIG_OK;
2809 } else if (obj == Py_False) {
2810 if (val) *val = false;
2811 return SWIG_OK;
2812 } else {
2813 long v = 0;
2814 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2815 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2816 return res;
2817 }
2818 }
2819
2820
2821 SWIGINTERN int
2822 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2823 {
2824 long v = 0;
2825 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2826 return SWIG_TypeError;
2827 }
2828 else if (val)
2829 *val = (unsigned long)v;
2830 return SWIG_OK;
2831 }
2832
2833
2834 SWIGINTERNINLINE PyObject*
2835 SWIG_From_unsigned_SS_long (unsigned long value)
2836 {
2837 return (value > LONG_MAX) ?
2838 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2839 }
2840
2841
2842 void* wxGetXDisplay()
2843 {
2844 #ifdef __WXGTK__
2845 return wxGetDisplay();
2846 #else
2847 return NULL;
2848 #endif
2849 }
2850
2851
2852 wxWindow* FindWindowAtPointer() {
2853 wxPoint unused;
2854 return wxFindWindowAtPointer(unused);
2855 }
2856
2857
2858 bool wxThread_IsMain() {
2859 #ifdef WXP_WITH_THREAD
2860 return wxThread::IsMain();
2861 #else
2862 return true;
2863 #endif
2864 }
2865
2866 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2867 delete self;
2868 }
2869
2870 #include <wx/snglinst.h>
2871
2872
2873 #ifdef __WXMSW__
2874 #include <wx/msw/private.h>
2875 #include <wx/dynload.h>
2876 #endif
2877
2878
2879
2880 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2881 #if 0
2882 , int method
2883 #endif
2884 )
2885 {
2886 #ifdef __WXMSW__
2887 #if 0
2888 switch (method)
2889 {
2890 case 1:
2891 // This one only partially works. Appears to be an undocumented
2892 // "standard" convention that not all widgets adhear to. For
2893 // example, for some widgets backgrounds or non-client areas may
2894 // not be painted.
2895 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2896 break;
2897
2898 case 2:
2899 #endif
2900 // This one works much better, nearly all widgets and their
2901 // children are captured correctly[**]. Prior to the big
2902 // background erase changes that Vadim did in 2004-2005 this
2903 // method failed badly on XP with Themes activated, most native
2904 // widgets draw only partially, if at all. Without themes it
2905 // worked just like on Win2k. After those changes this method
2906 // works very well.
2907 //
2908 // ** For example the radio buttons in a wxRadioBox are not its
2909 // children by default, but you can capture it via the panel
2910 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2911 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2912 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2913 PRF_ERASEBKGND | PRF_OWNED );
2914 return true;
2915 #if 0
2916 break;
2917
2918 case 3:
2919 // This one is only defined in the latest SDK and is only
2920 // available on XP. MSDN says it is similar to sending WM_PRINT
2921 // so I expect that it will work similar to the above. Since it
2922 // is avaialble only on XP, it can't be compiled like this and
2923 // will have to be loaded dynamically.
2924 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2925
2926 // fall through
2927
2928 case 4:
2929 // Use PrintWindow if available, or fallback to WM_PRINT
2930 // otherwise. Unfortunately using PrintWindow is even worse than
2931 // WM_PRINT. For most native widgets nothing is drawn to the dc
2932 // at all, with or without Themes.
2933 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2934 static bool s_triedToLoad = false;
2935 static PrintWindow_t pfnPrintWindow = NULL;
2936 if ( !s_triedToLoad )
2937 {
2938
2939 s_triedToLoad = true;
2940 wxDynamicLibrary dllUser32(_T("user32.dll"));
2941 if ( dllUser32.IsLoaded() )
2942 {
2943 wxLogNull nolog; // Don't report errors here
2944 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2945 }
2946 }
2947 if (pfnPrintWindow)
2948 {
2949 //printf("Using PrintWindow\n");
2950 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2951 }
2952 else
2953 {
2954 //printf("Using WM_PRINT\n");
2955 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2956 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2957 PRF_ERASEBKGND | PRF_OWNED );
2958 }
2959 }
2960 #endif // 0
2961 #else
2962 return false;
2963 #endif // __WXMSW__
2964 }
2965
2966
2967
2968 #include <wx/tipdlg.h>
2969
2970
2971 SWIGINTERNINLINE PyObject *
2972 SWIG_From_size_t (size_t value)
2973 {
2974 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2975 }
2976
2977
2978 class wxPyTipProvider : public wxTipProvider {
2979 public:
2980 wxPyTipProvider(size_t currentTip)
2981 : wxTipProvider(currentTip) {}
2982
2983 DEC_PYCALLBACK_STRING__pure(GetTip);
2984 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2985 PYPRIVATE;
2986 };
2987
2988 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2989 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2990
2991
2992 SWIGINTERNINLINE int
2993 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2994 {
2995 unsigned long v;
2996 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2997 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2998 return res;
2999 }
3000
3001
3002 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3003
3004 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3005
3006 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3007 : wxTimer(owner, id)
3008 {
3009 if (owner == NULL)
3010 SetOwner(this);
3011 }
3012
3013
3014 SWIGINTERN swig_type_info*
3015 SWIG_pchar_descriptor()
3016 {
3017 static int init = 0;
3018 static swig_type_info* info = 0;
3019 if (!init) {
3020 info = SWIG_TypeQuery("_p_char");
3021 init = 1;
3022 }
3023 return info;
3024 }
3025
3026
3027 SWIGINTERNINLINE PyObject *
3028 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3029 {
3030 if (carray) {
3031 if (size > INT_MAX) {
3032 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3033 return pchar_descriptor ?
3034 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3035 } else {
3036 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3037 }
3038 } else {
3039 return SWIG_Py_Void();
3040 }
3041 }
3042
3043
3044 SWIGINTERNINLINE PyObject *
3045 SWIG_FromCharPtr(const char *cptr)
3046 {
3047 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3048 }
3049
3050
3051 SWIGINTERN int
3052 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3053 {
3054 unsigned long v;
3055 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3056 if (SWIG_IsOK(res)) {
3057 if ((v > UINT_MAX)) {
3058 return SWIG_OverflowError;
3059 } else {
3060 if (val) *val = static_cast< unsigned int >(v);
3061 }
3062 }
3063 return res;
3064 }
3065
3066 SWIGINTERN wxString wxLog_TimeStamp(){
3067 wxString msg;
3068 wxLog::TimeStamp(&msg);
3069 return msg;
3070 }
3071 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3072 // Make some wrappers that double any % signs so they are 'escaped'
3073 void wxPyLogFatalError(const wxString& msg)
3074 {
3075 wxString m(msg);
3076 m.Replace(wxT("%"), wxT("%%"));
3077 wxLogFatalError(m);
3078 }
3079
3080 void wxPyLogError(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogError(m);
3085 }
3086
3087 void wxPyLogWarning(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogWarning(m);
3092 }
3093
3094 void wxPyLogMessage(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogMessage(m);
3099 }
3100
3101 void wxPyLogInfo(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogInfo(m);
3106 }
3107
3108 void wxPyLogDebug(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogDebug(m);
3113 }
3114
3115 void wxPyLogVerbose(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogVerbose(m);
3120 }
3121
3122 void wxPyLogStatus(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogStatus(m);
3127 }
3128
3129 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogStatus(pFrame, m);
3134 }
3135
3136 void wxPyLogSysError(const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogSysError(m);
3141 }
3142
3143 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogGeneric(level, m);
3148 }
3149
3150 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogTrace(mask, m);
3155 }
3156
3157 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogTrace(mask, m);
3162 }
3163
3164
3165
3166 // A wxLog class that can be derived from in wxPython
3167 class wxPyLog : public wxLog {
3168 public:
3169 wxPyLog() : wxLog() {}
3170
3171 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3172 bool found;
3173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3174 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3175 PyObject* s = wx2PyString(szString);
3176 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3177 Py_DECREF(s);
3178 }
3179 wxPyEndBlockThreads(blocked);
3180 if (! found)
3181 wxLog::DoLog(level, szString, t);
3182 }
3183
3184 virtual void DoLogString(const wxChar *szString, time_t t) {
3185 bool found;
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3188 PyObject* s = wx2PyString(szString);
3189 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3190 Py_DECREF(s);
3191 }
3192 wxPyEndBlockThreads(blocked);
3193 if (! found)
3194 wxLog::DoLogString(szString, t);
3195 }
3196
3197 DEC_PYCALLBACK_VOID_(Flush);
3198 PYPRIVATE;
3199 };
3200 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3201
3202
3203
3204
3205 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3206
3207
3208 #include <wx/joystick.h>
3209
3210
3211 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3212 // A C++ stub class for wxJoystick for platforms that don't have it.
3213 class wxJoystick : public wxObject {
3214 public:
3215 wxJoystick(int joystick = wxJOYSTICK1) {
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 PyErr_SetString(PyExc_NotImplementedError,
3218 "wxJoystick is not available on this platform.");
3219 wxPyEndBlockThreads(blocked);
3220 }
3221 wxPoint GetPosition() { return wxPoint(-1,-1); }
3222 int GetZPosition() { return -1; }
3223 int GetButtonState() { return -1; }
3224 int GetPOVPosition() { return -1; }
3225 int GetPOVCTSPosition() { return -1; }
3226 int GetRudderPosition() { return -1; }
3227 int GetUPosition() { return -1; }
3228 int GetVPosition() { return -1; }
3229 int GetMovementThreshold() { return -1; }
3230 void SetMovementThreshold(int threshold) {}
3231
3232 bool IsOk(void) { return false; }
3233 int GetNumberJoysticks() { return -1; }
3234 int GetManufacturerId() { return -1; }
3235 int GetProductId() { return -1; }
3236 wxString GetProductName() { return wxEmptyString; }
3237 int GetXMin() { return -1; }
3238 int GetYMin() { return -1; }
3239 int GetZMin() { return -1; }
3240 int GetXMax() { return -1; }
3241 int GetYMax() { return -1; }
3242 int GetZMax() { return -1; }
3243 int GetNumberButtons() { return -1; }
3244 int GetNumberAxes() { return -1; }
3245 int GetMaxButtons() { return -1; }
3246 int GetMaxAxes() { return -1; }
3247 int GetPollingMin() { return -1; }
3248 int GetPollingMax() { return -1; }
3249 int GetRudderMin() { return -1; }
3250 int GetRudderMax() { return -1; }
3251 int GetUMin() { return -1; }
3252 int GetUMax() { return -1; }
3253 int GetVMin() { return -1; }
3254 int GetVMax() { return -1; }
3255
3256 bool HasRudder() { return false; }
3257 bool HasZ() { return false; }
3258 bool HasU() { return false; }
3259 bool HasV() { return false; }
3260 bool HasPOV() { return false; }
3261 bool HasPOV4Dir() { return false; }
3262 bool HasPOVCTS() { return false; }
3263
3264 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3265 bool ReleaseCapture() { return false; }
3266 };
3267 #endif
3268
3269
3270 #include <wx/sound.h>
3271
3272
3273 #if !wxUSE_SOUND
3274 // A C++ stub class for wxWave for platforms that don't have it.
3275 class wxSound : public wxObject
3276 {
3277 public:
3278 wxSound() {
3279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3280 PyErr_SetString(PyExc_NotImplementedError,
3281 "wxSound is not available on this platform.");
3282 wxPyEndBlockThreads(blocked);
3283 }
3284 wxSound(const wxString&/*, bool*/) {
3285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3286 PyErr_SetString(PyExc_NotImplementedError,
3287 "wxSound is not available on this platform.");
3288 wxPyEndBlockThreads(blocked);
3289 }
3290 wxSound(int, const wxByte*) {
3291 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3292 PyErr_SetString(PyExc_NotImplementedError,
3293 "wxSound is not available on this platform.");
3294 wxPyEndBlockThreads(blocked);
3295 }
3296
3297 ~wxSound() {};
3298
3299 bool Create(const wxString&/*, bool*/) { return false; }
3300 bool Create(int, const wxByte*) { return false; };
3301 bool IsOk() { return false; };
3302 bool Play(unsigned) const { return false; }
3303 static bool Play(const wxString&, unsigned) { return false; }
3304 static void Stop() {}
3305 };
3306
3307 #endif
3308
3309 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3310 if (fileName.Length() == 0)
3311 return new wxSound;
3312 else
3313 return new wxSound(fileName);
3314 }
3315 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3316 unsigned char* buffer; int size;
3317 wxSound *sound = NULL;
3318
3319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3320 if (!PyArg_Parse(data, "t#", &buffer, &size))
3321 goto done;
3322 sound = new wxSound(size, buffer);
3323 done:
3324 wxPyEndBlockThreads(blocked);
3325 return sound;
3326 }
3327 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3328 #ifndef __WXMAC__
3329 unsigned char* buffer;
3330 int size;
3331 bool rv = false;
3332
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 if (!PyArg_Parse(data, "t#", &buffer, &size))
3335 goto done;
3336 rv = self->Create(size, buffer);
3337 done:
3338 wxPyEndBlockThreads(blocked);
3339 return rv;
3340 #else
3341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3342 PyErr_SetString(PyExc_NotImplementedError,
3343 "Create from data is not available on this platform.");
3344 wxPyEndBlockThreads(blocked);
3345 return false;
3346 #endif
3347 }
3348
3349 #include <wx/mimetype.h>
3350
3351 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3352 wxString str;
3353 if (self->GetMimeType(&str))
3354 return wx2PyString(str);
3355 else
3356 RETURN_NONE();
3357 }
3358 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3359 wxArrayString arr;
3360 if (self->GetMimeTypes(arr))
3361 return wxArrayString2PyList_helper(arr);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3366 wxArrayString arr;
3367 if (self->GetExtensions(arr))
3368 return wxArrayString2PyList_helper(arr);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3373 wxIconLocation loc;
3374 if (self->GetIcon(&loc))
3375 return new wxIcon(loc);
3376 else
3377 return NULL;
3378 }
3379 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3380 wxIconLocation loc;
3381 if (self->GetIcon(&loc)) {
3382 wxString iconFile = loc.GetFileName();
3383 int iconIndex = -1;
3384
3385
3386
3387 // Make a tuple and put the values in it
3388 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3389 PyObject* tuple = PyTuple_New(3);
3390 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3391 wxT("wxIcon"), true));
3392 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3393 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3394 wxPyEndBlockThreads(blocked);
3395 return tuple;
3396 }
3397 else
3398 RETURN_NONE();
3399 }
3400 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3401 wxString str;
3402 if (self->GetDescription(&str))
3403 return wx2PyString(str);
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3408 wxString str;
3409 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxString str;
3416 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxArrayString verbs;
3423 wxArrayString commands;
3424 if (self->GetAllCommands(&verbs, &commands,
3425 wxFileType::MessageParameters(filename, mimetype))) {
3426 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3427 PyObject* tuple = PyTuple_New(2);
3428 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3429 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3430 wxPyEndBlockThreads(blocked);
3431 return tuple;
3432 }
3433 else
3434 RETURN_NONE();
3435 }
3436 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3437 return wxFileType::ExpandCommand(command,
3438 wxFileType::MessageParameters(filename, mimetype));
3439 }
3440 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3441 wxArrayString arr;
3442 self->EnumAllFileTypes(arr);
3443 return wxArrayString2PyList_helper(arr);
3444 }
3445
3446 #include <wx/artprov.h>
3447
3448 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3449 static const wxString wxPyART_MENU(wxART_MENU);
3450 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3451 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3452 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3453 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3454 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3455 static const wxString wxPyART_OTHER(wxART_OTHER);
3456 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3457 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3458 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3459 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3460 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3461 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3462 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3463 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3464 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3465 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3466 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3467 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3468 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3469 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3470 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3471 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3472 static const wxString wxPyART_PRINT(wxART_PRINT);
3473 static const wxString wxPyART_HELP(wxART_HELP);
3474 static const wxString wxPyART_TIP(wxART_TIP);
3475 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3476 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3477 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3478 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3479 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3480 static const wxString wxPyART_CDROM(wxART_CDROM);
3481 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3482 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3483 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3484 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3485 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3486 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3487 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3488 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3489 static const wxString wxPyART_ERROR(wxART_ERROR);
3490 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3491 static const wxString wxPyART_WARNING(wxART_WARNING);
3492 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3493 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3494 static const wxString wxPyART_COPY(wxART_COPY);
3495 static const wxString wxPyART_CUT(wxART_CUT);
3496 static const wxString wxPyART_PASTE(wxART_PASTE);
3497 static const wxString wxPyART_DELETE(wxART_DELETE);
3498 static const wxString wxPyART_NEW(wxART_NEW);
3499 static const wxString wxPyART_UNDO(wxART_UNDO);
3500 static const wxString wxPyART_REDO(wxART_REDO);
3501 static const wxString wxPyART_QUIT(wxART_QUIT);
3502 static const wxString wxPyART_FIND(wxART_FIND);
3503 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3504 // Python aware wxArtProvider
3505 class wxPyArtProvider : public wxArtProvider {
3506 public:
3507
3508 virtual wxBitmap CreateBitmap(const wxArtID& id,
3509 const wxArtClient& client,
3510 const wxSize& size) {
3511 wxBitmap rval = wxNullBitmap;
3512 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3513 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3514 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3515 PyObject* ro;
3516 wxBitmap* ptr;
3517 PyObject* s1, *s2;
3518 s1 = wx2PyString(id);
3519 s2 = wx2PyString(client);
3520 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3521 Py_DECREF(so);
3522 Py_DECREF(s1);
3523 Py_DECREF(s2);
3524 if (ro) {
3525 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3526 rval = *ptr;
3527 Py_DECREF(ro);
3528 }
3529 }
3530 wxPyEndBlockThreads(blocked);
3531 return rval;
3532 }
3533
3534 PYPRIVATE;
3535 };
3536
3537 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3538
3539
3540
3541 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3542 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3543 PyObject* ret = PyTuple_New(3);
3544 if (ret) {
3545 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3546 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3547 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3548 }
3549 wxPyEndBlockThreads(blocked);
3550 return ret;
3551 }
3552
3553 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3554 bool cont;
3555 long index = 0;
3556 wxString value;
3557
3558 cont = self->GetFirstGroup(value, index);
3559 return __EnumerationHelper(cont, value, index);
3560 }
3561 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3562 bool cont;
3563 wxString value;
3564
3565 cont = self->GetNextGroup(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3569 bool cont;
3570 long index = 0;
3571 wxString value;
3572
3573 cont = self->GetFirstEntry(value, index);
3574 return __EnumerationHelper(cont, value, index);
3575 }
3576 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3577 bool cont;
3578 wxString value;
3579
3580 cont = self->GetNextEntry(value, index);
3581 return __EnumerationHelper(cont, value, index);
3582 }
3583 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3584 long rv;
3585 self->Read(key, &rv, defaultVal);
3586 return rv;
3587 }
3588
3589 SWIGINTERN int
3590 SWIG_AsVal_double (PyObject *obj, double* val)
3591 {
3592 if (PyNumber_Check(obj)) {
3593 if (val) *val = PyFloat_AsDouble(obj);
3594 return SWIG_OK;
3595 }
3596 return SWIG_TypeError;
3597 }
3598
3599 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3600 double rv;
3601 self->Read(key, &rv, defaultVal);
3602 return rv;
3603 }
3604
3605 #define SWIG_From_double PyFloat_FromDouble
3606
3607 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3608 bool rv;
3609 self->Read(key, &rv, defaultVal);
3610 return rv;
3611 }
3612
3613 #include <wx/datetime.h>
3614
3615 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3616 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3617
3618 #define LOCAL_TZ wxDateTime::Local
3619
3620 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3621 wxString am;
3622 wxString pm;
3623 wxDateTime::GetAmPmStrings(&am, &pm);
3624 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3625 PyObject* tup = PyTuple_New(2);
3626 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3627 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3628 wxPyEndBlockThreads(blocked);
3629 return tup;
3630 }
3631
3632 SWIGINTERNINLINE PyObject *
3633 SWIG_From_unsigned_SS_int (unsigned int value)
3634 {
3635 return SWIG_From_unsigned_SS_long (value);
3636 }
3637
3638 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3639 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3640 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3641 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3642 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3643 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3644 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3645 return (*self < *other);
3646 }
3647 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3649 return (*self <= *other);
3650 }
3651 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3653 return (*self > *other);
3654 }
3655 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3657 return (*self >= *other);
3658 }
3659 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3661 return (*self == *other);
3662 }
3663 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3664 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3665 return (*self != *other);
3666 }
3667 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3668 const wxChar* rv;
3669 const wxChar* _date = date;
3670 rv = self->ParseRfc822Date(_date);
3671 if (rv == NULL) return -1;
3672 return rv - _date;
3673 }
3674 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3675 const wxChar* rv;
3676 const wxChar* _date = date;
3677 rv = self->ParseFormat(_date, format, dateDef);
3678 if (rv == NULL) return -1;
3679 return rv - _date;
3680 }
3681 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3682 const wxChar* rv;
3683 const wxChar* _datetime = datetime;
3684 rv = self->ParseDateTime(_datetime);
3685 if (rv == NULL) return -1;
3686 return rv - _datetime;
3687 }
3688 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3689 const wxChar* rv;
3690 const wxChar* _date = date;
3691 rv = self->ParseDate(_date);
3692 if (rv == NULL) return -1;
3693 return rv - _date;
3694 }
3695 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3696 const wxChar* rv;
3697 const wxChar* _time = time;
3698 rv = self->ParseTime(_time);
3699 if (rv == NULL) return -1;
3700 return rv - _time;
3701 }
3702 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3703 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3704 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3705 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3706 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3707 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3708 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3709 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3710 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3711 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3712 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3713 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3714 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3715 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3716 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3717 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3718
3719 #include <wx/dataobj.h>
3720
3721 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3722 size_t count = self->GetFormatCount(dir);
3723 wxDataFormat* formats = new wxDataFormat[count];
3724 self->GetAllFormats(formats, dir);
3725
3726 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3727 PyObject* list = PyList_New(count);
3728 for (size_t i=0; i<count; i++) {
3729 wxDataFormat* format = new wxDataFormat(formats[i]);
3730 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3731 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3732 }
3733 wxPyEndBlockThreads(blocked);
3734 delete [] formats;
3735 return list;
3736 }
3737 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3738 PyObject* rval = NULL;
3739 size_t size = self->GetDataSize(format);
3740 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3741 if (size) {
3742 char* buf = new char[size];
3743 if (self->GetDataHere(format, buf))
3744 rval = PyString_FromStringAndSize(buf, size);
3745 delete [] buf;
3746 }
3747 if (! rval) {
3748 rval = Py_None;
3749 Py_INCREF(rval);
3750 }
3751 wxPyEndBlockThreads(blocked);
3752 return rval;
3753 }
3754 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3755 bool rval;
3756 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3757 if (PyString_Check(data)) {
3758 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3759 }
3760 else {
3761 // raise a TypeError if not a string
3762 PyErr_SetString(PyExc_TypeError, "String expected.");
3763 rval = false;
3764 }
3765 wxPyEndBlockThreads(blocked);
3766 return rval;
3767 }
3768 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3769 PyObject* rval = NULL;
3770 size_t size = self->GetDataSize();
3771 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3772 if (size) {
3773 char* buf = new char[size];
3774 if (self->GetDataHere(buf))
3775 rval = PyString_FromStringAndSize(buf, size);
3776 delete [] buf;
3777 }
3778 if (! rval) {
3779 rval = Py_None;
3780 Py_INCREF(rval);
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return rval;
3784 }
3785 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3786 bool rval;
3787 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3788 if (PyString_Check(data)) {
3789 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3790 }
3791 else {
3792 // raise a TypeError if not a string
3793 PyErr_SetString(PyExc_TypeError, "String expected.");
3794 rval = false;
3795 }
3796 wxPyEndBlockThreads(blocked);
3797 return rval;
3798 }
3799 // Create a new class for wxPython to use
3800 class wxPyDataObjectSimple : public wxDataObjectSimple {
3801 public:
3802 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3803 : wxDataObjectSimple(format) {}
3804
3805 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3806 bool GetDataHere(void *buf) const;
3807 bool SetData(size_t len, const void *buf);
3808 PYPRIVATE;
3809 };
3810
3811 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3812
3813 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3814 // We need to get the data for this object and write it to buf. I think
3815 // the best way to do this for wxPython is to have the Python method
3816 // return either a string or None and then act appropriately with the
3817 // C++ version.
3818
3819 bool rval = false;
3820 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3821 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3822 PyObject* ro;
3823 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3824 if (ro) {
3825 rval = (ro != Py_None && PyString_Check(ro));
3826 if (rval)
3827 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3828 Py_DECREF(ro);
3829 }
3830 }
3831 wxPyEndBlockThreads(blocked);
3832 return rval;
3833 }
3834
3835 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3836 // For this one we simply need to make a string from buf and len
3837 // and send it to the Python method.
3838 bool rval = false;
3839 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3840 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3841 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3842 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3843 Py_DECREF(data);
3844 }
3845 wxPyEndBlockThreads(blocked);
3846 return rval;
3847 }
3848
3849 // Create a new class for wxPython to use
3850 class wxPyTextDataObject : public wxTextDataObject {
3851 public:
3852 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3853 : wxTextDataObject(text) {}
3854
3855 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3856 DEC_PYCALLBACK_STRING__const(GetText);
3857 DEC_PYCALLBACK__STRING(SetText);
3858 PYPRIVATE;
3859 };
3860
3861 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3862 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3863 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3864
3865
3866 // Create a new class for wxPython to use
3867 class wxPyBitmapDataObject : public wxBitmapDataObject {
3868 public:
3869 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3870 : wxBitmapDataObject(bitmap) {}
3871
3872 wxBitmap GetBitmap() const;
3873 void SetBitmap(const wxBitmap& bitmap);
3874 PYPRIVATE;
3875 };
3876
3877 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3878 wxBitmap* rval = &wxNullBitmap;
3879 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3880 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3881 PyObject* ro;
3882 wxBitmap* ptr;
3883 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3884 if (ro) {
3885 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3886 rval = ptr;
3887 Py_DECREF(ro);
3888 }
3889 }
3890 wxPyEndBlockThreads(blocked);
3891 return *rval;
3892 }
3893
3894 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3895 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3896 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3897 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3898 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3899 Py_DECREF(bo);
3900 }
3901 wxPyEndBlockThreads(blocked);
3902 }
3903
3904 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3905 return new wxCustomDataObject(wxDataFormat(formatName));
3906 }
3907 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3908 bool rval;
3909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3910 if (PyString_Check(data)) {
3911 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3912 }
3913 else {
3914 // raise a TypeError if not a string
3915 PyErr_SetString(PyExc_TypeError, "String expected.");
3916 rval = false;
3917 }
3918 wxPyEndBlockThreads(blocked);
3919 return rval;
3920 }
3921 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3922 PyObject* obj;
3923 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3924 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3925 wxPyEndBlockThreads(blocked);
3926 return obj;
3927 }
3928
3929 #include <wx/metafile.h>
3930
3931
3932 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3933
3934
3935 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3936 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3937 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3938 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3939 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3940
3941
3942 class wxPyTextDropTarget : public wxTextDropTarget {
3943 public:
3944 wxPyTextDropTarget() {}
3945
3946 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3947
3948 DEC_PYCALLBACK__(OnLeave);
3949 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3950 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3951 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3952 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3953
3954 PYPRIVATE;
3955 };
3956
3957 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3958 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3959 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3960 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3961 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3962 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3963
3964
3965
3966 class wxPyFileDropTarget : public wxFileDropTarget {
3967 public:
3968 wxPyFileDropTarget() {}
3969
3970 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3971
3972 DEC_PYCALLBACK__(OnLeave);
3973 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3974 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3975 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3976 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3977
3978 PYPRIVATE;
3979 };
3980
3981 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3982 const wxArrayString& filenames) {
3983 bool rval = false;
3984 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3985 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3986 PyObject* list = wxArrayString2PyList_helper(filenames);
3987 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3988 Py_DECREF(list);
3989 }
3990 wxPyEndBlockThreads(blocked);
3991 return rval;
3992 }
3993
3994
3995
3996 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3997 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3998 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3999 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4000 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4001
4002
4003
4004
4005 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4006
4007 #include <wx/display.h>
4008
4009 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4010 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4011
4012 #if !wxUSE_DISPLAY
4013 const wxVideoMode wxDefaultVideoMode;
4014 #endif
4015
4016 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4017 #if wxUSE_DISPLAY
4018 PyObject* pyList = NULL;
4019 wxArrayVideoModes arr = self->GetModes(mode);
4020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4021 pyList = PyList_New(0);
4022 for (size_t i=0; i < arr.GetCount(); i++)
4023 {
4024 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4025 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4026 PyList_Append(pyList, pyObj);
4027 Py_DECREF(pyObj);
4028 }
4029 wxPyEndBlockThreads(blocked);
4030 return pyList;
4031 #else
4032 wxPyRaiseNotImplemented();
4033 return NULL;
4034 #endif
4035 }
4036 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4037 #if wxUSE_DISPLAY
4038 return self->GetCurrentMode();
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return wxDefaultVideoMode;
4042 #endif
4043 }
4044 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4045 #if wxUSE_DISPLAY
4046 return self->ChangeMode(mode);
4047 #else
4048 wxPyRaiseNotImplemented();
4049 return false;
4050 #endif
4051 }
4052 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4053 #if wxUSE_DISPLAY
4054 self->ResetMode();
4055 #else
4056 wxPyRaiseNotImplemented();
4057 #endif
4058 }
4059
4060 #include <wx/stdpaths.h>
4061
4062 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4063 return (wxStandardPaths*) &wxStandardPaths::Get();
4064 }
4065 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4066 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4067
4068 #ifndef wxHAS_POWER_EVENTS
4069 // Dummy class and other definitions for platforms that don't have them
4070
4071 // See wxPython_int.h for wxPowerEvent
4072
4073 enum {
4074 wxEVT_POWER_SUSPENDING,
4075 wxEVT_POWER_SUSPENDED,
4076 wxEVT_POWER_SUSPEND_CANCEL,
4077 wxEVT_POWER_RESUME,
4078 };
4079
4080 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4081 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4082
4083 #endif
4084
4085
4086 #include <wx/aboutdlg.h>
4087
4088 #ifdef __cplusplus
4089 extern "C" {
4090 #endif
4091 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4092 PyObject *resultobj = 0;
4093 wxSystemColour arg1 ;
4094 wxColour result;
4095 int val1 ;
4096 int ecode1 = 0 ;
4097 PyObject * obj0 = 0 ;
4098 char * kwnames[] = {
4099 (char *) "index", NULL
4100 };
4101
4102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4103 ecode1 = SWIG_AsVal_int(obj0, &val1);
4104 if (!SWIG_IsOK(ecode1)) {
4105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4106 }
4107 arg1 = static_cast< wxSystemColour >(val1);
4108 {
4109 if (!wxPyCheckForApp()) SWIG_fail;
4110 PyThreadState* __tstate = wxPyBeginAllowThreads();
4111 result = wxSystemSettings::GetColour(arg1);
4112 wxPyEndAllowThreads(__tstate);
4113 if (PyErr_Occurred()) SWIG_fail;
4114 }
4115 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4116 return resultobj;
4117 fail:
4118 return NULL;
4119 }
4120
4121
4122 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4123 PyObject *resultobj = 0;
4124 wxSystemFont arg1 ;
4125 wxFont result;
4126 int val1 ;
4127 int ecode1 = 0 ;
4128 PyObject * obj0 = 0 ;
4129 char * kwnames[] = {
4130 (char *) "index", NULL
4131 };
4132
4133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4134 ecode1 = SWIG_AsVal_int(obj0, &val1);
4135 if (!SWIG_IsOK(ecode1)) {
4136 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4137 }
4138 arg1 = static_cast< wxSystemFont >(val1);
4139 {
4140 if (!wxPyCheckForApp()) SWIG_fail;
4141 PyThreadState* __tstate = wxPyBeginAllowThreads();
4142 result = wxSystemSettings::GetFont(arg1);
4143 wxPyEndAllowThreads(__tstate);
4144 if (PyErr_Occurred()) SWIG_fail;
4145 }
4146 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4147 return resultobj;
4148 fail:
4149 return NULL;
4150 }
4151
4152
4153 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4154 PyObject *resultobj = 0;
4155 wxSystemMetric arg1 ;
4156 wxWindow *arg2 = (wxWindow *) NULL ;
4157 int result;
4158 int val1 ;
4159 int ecode1 = 0 ;
4160 void *argp2 = 0 ;
4161 int res2 = 0 ;
4162 PyObject * obj0 = 0 ;
4163 PyObject * obj1 = 0 ;
4164 char * kwnames[] = {
4165 (char *) "index",(char *) "win", NULL
4166 };
4167
4168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4169 ecode1 = SWIG_AsVal_int(obj0, &val1);
4170 if (!SWIG_IsOK(ecode1)) {
4171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4172 }
4173 arg1 = static_cast< wxSystemMetric >(val1);
4174 if (obj1) {
4175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4176 if (!SWIG_IsOK(res2)) {
4177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4178 }
4179 arg2 = reinterpret_cast< wxWindow * >(argp2);
4180 }
4181 {
4182 if (!wxPyCheckForApp()) SWIG_fail;
4183 PyThreadState* __tstate = wxPyBeginAllowThreads();
4184 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4185 wxPyEndAllowThreads(__tstate);
4186 if (PyErr_Occurred()) SWIG_fail;
4187 }
4188 resultobj = SWIG_From_int(static_cast< int >(result));
4189 return resultobj;
4190 fail:
4191 return NULL;
4192 }
4193
4194
4195 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4196 PyObject *resultobj = 0;
4197 wxSystemFeature arg1 ;
4198 bool result;
4199 int val1 ;
4200 int ecode1 = 0 ;
4201 PyObject * obj0 = 0 ;
4202 char * kwnames[] = {
4203 (char *) "index", NULL
4204 };
4205
4206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4207 ecode1 = SWIG_AsVal_int(obj0, &val1);
4208 if (!SWIG_IsOK(ecode1)) {
4209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4210 }
4211 arg1 = static_cast< wxSystemFeature >(val1);
4212 {
4213 if (!wxPyCheckForApp()) SWIG_fail;
4214 PyThreadState* __tstate = wxPyBeginAllowThreads();
4215 result = (bool)wxSystemSettings::HasFeature(arg1);
4216 wxPyEndAllowThreads(__tstate);
4217 if (PyErr_Occurred()) SWIG_fail;
4218 }
4219 {
4220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4221 }
4222 return resultobj;
4223 fail:
4224 return NULL;
4225 }
4226
4227
4228 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4229 PyObject *resultobj = 0;
4230 wxSystemScreenType result;
4231
4232 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4233 {
4234 if (!wxPyCheckForApp()) SWIG_fail;
4235 PyThreadState* __tstate = wxPyBeginAllowThreads();
4236 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4237 wxPyEndAllowThreads(__tstate);
4238 if (PyErr_Occurred()) SWIG_fail;
4239 }
4240 resultobj = SWIG_From_int(static_cast< int >(result));
4241 return resultobj;
4242 fail:
4243 return NULL;
4244 }
4245
4246
4247 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4248 PyObject *resultobj = 0;
4249 wxSystemScreenType arg1 ;
4250 int val1 ;
4251 int ecode1 = 0 ;
4252 PyObject * obj0 = 0 ;
4253 char * kwnames[] = {
4254 (char *) "screen", NULL
4255 };
4256
4257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4258 ecode1 = SWIG_AsVal_int(obj0, &val1);
4259 if (!SWIG_IsOK(ecode1)) {
4260 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4261 }
4262 arg1 = static_cast< wxSystemScreenType >(val1);
4263 {
4264 if (!wxPyCheckForApp()) SWIG_fail;
4265 PyThreadState* __tstate = wxPyBeginAllowThreads();
4266 wxSystemSettings::SetScreenType(arg1);
4267 wxPyEndAllowThreads(__tstate);
4268 if (PyErr_Occurred()) SWIG_fail;
4269 }
4270 resultobj = SWIG_Py_Void();
4271 return resultobj;
4272 fail:
4273 return NULL;
4274 }
4275
4276
4277 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4278 PyObject *obj;
4279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4280 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4281 return SWIG_Py_Void();
4282 }
4283
4284 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4285 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4286 return 1;
4287 }
4288
4289
4290 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4291 PyObject *pyobj = 0;
4292
4293 {
4294 #if wxUSE_UNICODE
4295 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4296 #else
4297 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4298 #endif
4299 }
4300 return pyobj;
4301 }
4302
4303
4304 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4305 PyObject *resultobj = 0;
4306 wxSystemOptions *result = 0 ;
4307
4308 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4309 {
4310 PyThreadState* __tstate = wxPyBeginAllowThreads();
4311 result = (wxSystemOptions *)new wxSystemOptions();
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4316 return resultobj;
4317 fail:
4318 return NULL;
4319 }
4320
4321
4322 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4323 PyObject *resultobj = 0;
4324 wxString *arg1 = 0 ;
4325 wxString *arg2 = 0 ;
4326 bool temp1 = false ;
4327 bool temp2 = false ;
4328 PyObject * obj0 = 0 ;
4329 PyObject * obj1 = 0 ;
4330 char * kwnames[] = {
4331 (char *) "name",(char *) "value", NULL
4332 };
4333
4334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4335 {
4336 arg1 = wxString_in_helper(obj0);
4337 if (arg1 == NULL) SWIG_fail;
4338 temp1 = true;
4339 }
4340 {
4341 arg2 = wxString_in_helper(obj1);
4342 if (arg2 == NULL) SWIG_fail;
4343 temp2 = true;
4344 }
4345 {
4346 PyThreadState* __tstate = wxPyBeginAllowThreads();
4347 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4348 wxPyEndAllowThreads(__tstate);
4349 if (PyErr_Occurred()) SWIG_fail;
4350 }
4351 resultobj = SWIG_Py_Void();
4352 {
4353 if (temp1)
4354 delete arg1;
4355 }
4356 {
4357 if (temp2)
4358 delete arg2;
4359 }
4360 return resultobj;
4361 fail:
4362 {
4363 if (temp1)
4364 delete arg1;
4365 }
4366 {
4367 if (temp2)
4368 delete arg2;
4369 }
4370 return NULL;
4371 }
4372
4373
4374 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4375 PyObject *resultobj = 0;
4376 wxString *arg1 = 0 ;
4377 int arg2 ;
4378 bool temp1 = false ;
4379 int val2 ;
4380 int ecode2 = 0 ;
4381 PyObject * obj0 = 0 ;
4382 PyObject * obj1 = 0 ;
4383 char * kwnames[] = {
4384 (char *) "name",(char *) "value", NULL
4385 };
4386
4387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4388 {
4389 arg1 = wxString_in_helper(obj0);
4390 if (arg1 == NULL) SWIG_fail;
4391 temp1 = true;
4392 }
4393 ecode2 = SWIG_AsVal_int(obj1, &val2);
4394 if (!SWIG_IsOK(ecode2)) {
4395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4396 }
4397 arg2 = static_cast< int >(val2);
4398 {
4399 PyThreadState* __tstate = wxPyBeginAllowThreads();
4400 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4401 wxPyEndAllowThreads(__tstate);
4402 if (PyErr_Occurred()) SWIG_fail;
4403 }
4404 resultobj = SWIG_Py_Void();
4405 {
4406 if (temp1)
4407 delete arg1;
4408 }
4409 return resultobj;
4410 fail:
4411 {
4412 if (temp1)
4413 delete arg1;
4414 }
4415 return NULL;
4416 }
4417
4418
4419 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4420 PyObject *resultobj = 0;
4421 wxString *arg1 = 0 ;
4422 wxString result;
4423 bool temp1 = false ;
4424 PyObject * obj0 = 0 ;
4425 char * kwnames[] = {
4426 (char *) "name", NULL
4427 };
4428
4429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4430 {
4431 arg1 = wxString_in_helper(obj0);
4432 if (arg1 == NULL) SWIG_fail;
4433 temp1 = true;
4434 }
4435 {
4436 PyThreadState* __tstate = wxPyBeginAllowThreads();
4437 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4438 wxPyEndAllowThreads(__tstate);
4439 if (PyErr_Occurred()) SWIG_fail;
4440 }
4441 {
4442 #if wxUSE_UNICODE
4443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4444 #else
4445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4446 #endif
4447 }
4448 {
4449 if (temp1)
4450 delete arg1;
4451 }
4452 return resultobj;
4453 fail:
4454 {
4455 if (temp1)
4456 delete arg1;
4457 }
4458 return NULL;
4459 }
4460
4461
4462 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4463 PyObject *resultobj = 0;
4464 wxString *arg1 = 0 ;
4465 int result;
4466 bool temp1 = false ;
4467 PyObject * obj0 = 0 ;
4468 char * kwnames[] = {
4469 (char *) "name", NULL
4470 };
4471
4472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4473 {
4474 arg1 = wxString_in_helper(obj0);
4475 if (arg1 == NULL) SWIG_fail;
4476 temp1 = true;
4477 }
4478 {
4479 PyThreadState* __tstate = wxPyBeginAllowThreads();
4480 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4481 wxPyEndAllowThreads(__tstate);
4482 if (PyErr_Occurred()) SWIG_fail;
4483 }
4484 resultobj = SWIG_From_int(static_cast< int >(result));
4485 {
4486 if (temp1)
4487 delete arg1;
4488 }
4489 return resultobj;
4490 fail:
4491 {
4492 if (temp1)
4493 delete arg1;
4494 }
4495 return NULL;
4496 }
4497
4498
4499 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4500 PyObject *resultobj = 0;
4501 wxString *arg1 = 0 ;
4502 bool result;
4503 bool temp1 = false ;
4504 PyObject * obj0 = 0 ;
4505 char * kwnames[] = {
4506 (char *) "name", NULL
4507 };
4508
4509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4510 {
4511 arg1 = wxString_in_helper(obj0);
4512 if (arg1 == NULL) SWIG_fail;
4513 temp1 = true;
4514 }
4515 {
4516 PyThreadState* __tstate = wxPyBeginAllowThreads();
4517 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4518 wxPyEndAllowThreads(__tstate);
4519 if (PyErr_Occurred()) SWIG_fail;
4520 }
4521 {
4522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4523 }
4524 {
4525 if (temp1)
4526 delete arg1;
4527 }
4528 return resultobj;
4529 fail:
4530 {
4531 if (temp1)
4532 delete arg1;
4533 }
4534 return NULL;
4535 }
4536
4537
4538 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4539 PyObject *resultobj = 0;
4540 wxString *arg1 = 0 ;
4541 bool result;
4542 bool temp1 = false ;
4543 PyObject * obj0 = 0 ;
4544 char * kwnames[] = {
4545 (char *) "name", NULL
4546 };
4547
4548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4549 {
4550 arg1 = wxString_in_helper(obj0);
4551 if (arg1 == NULL) SWIG_fail;
4552 temp1 = true;
4553 }
4554 {
4555 PyThreadState* __tstate = wxPyBeginAllowThreads();
4556 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4557 wxPyEndAllowThreads(__tstate);
4558 if (PyErr_Occurred()) SWIG_fail;
4559 }
4560 {
4561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4562 }
4563 {
4564 if (temp1)
4565 delete arg1;
4566 }
4567 return resultobj;
4568 fail:
4569 {
4570 if (temp1)
4571 delete arg1;
4572 }
4573 return NULL;
4574 }
4575
4576
4577 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4578 PyObject *obj;
4579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4580 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4581 return SWIG_Py_Void();
4582 }
4583
4584 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4585 return SWIG_Python_InitShadowInstance(args);
4586 }
4587
4588 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4589 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4590 return 1;
4591 }
4592
4593
4594 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4595 PyObject *pyobj = 0;
4596
4597 {
4598 #if wxUSE_UNICODE
4599 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4600 #else
4601 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4602 #endif
4603 }
4604 return pyobj;
4605 }
4606
4607
4608 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4609 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4610 return 1;
4611 }
4612
4613
4614 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4615 PyObject *pyobj = 0;
4616
4617 {
4618 #if wxUSE_UNICODE
4619 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4620 #else
4621 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4622 #endif
4623 }
4624 return pyobj;
4625 }
4626
4627
4628 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4629 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4630 return 1;
4631 }
4632
4633
4634 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4635 PyObject *pyobj = 0;
4636
4637 {
4638 #if wxUSE_UNICODE
4639 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4640 #else
4641 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4642 #endif
4643 }
4644 return pyobj;
4645 }
4646
4647
4648 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4649 PyObject *resultobj = 0;
4650 long result;
4651
4652 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4653 {
4654 PyThreadState* __tstate = wxPyBeginAllowThreads();
4655 result = (long)wxNewId();
4656 wxPyEndAllowThreads(__tstate);
4657 if (PyErr_Occurred()) SWIG_fail;
4658 }
4659 resultobj = SWIG_From_long(static_cast< long >(result));
4660 return resultobj;
4661 fail:
4662 return NULL;
4663 }
4664
4665
4666 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4667 PyObject *resultobj = 0;
4668 long arg1 ;
4669 long val1 ;
4670 int ecode1 = 0 ;
4671 PyObject * obj0 = 0 ;
4672 char * kwnames[] = {
4673 (char *) "id", NULL
4674 };
4675
4676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4677 ecode1 = SWIG_AsVal_long(obj0, &val1);
4678 if (!SWIG_IsOK(ecode1)) {
4679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4680 }
4681 arg1 = static_cast< long >(val1);
4682 {
4683 PyThreadState* __tstate = wxPyBeginAllowThreads();
4684 wxRegisterId(arg1);
4685 wxPyEndAllowThreads(__tstate);
4686 if (PyErr_Occurred()) SWIG_fail;
4687 }
4688 resultobj = SWIG_Py_Void();
4689 return resultobj;
4690 fail:
4691 return NULL;
4692 }
4693
4694
4695 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4696 PyObject *resultobj = 0;
4697 long result;
4698
4699 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4700 {
4701 PyThreadState* __tstate = wxPyBeginAllowThreads();
4702 result = (long)wxGetCurrentId();
4703 wxPyEndAllowThreads(__tstate);
4704 if (PyErr_Occurred()) SWIG_fail;
4705 }
4706 resultobj = SWIG_From_long(static_cast< long >(result));
4707 return resultobj;
4708 fail:
4709 return NULL;
4710 }
4711
4712
4713 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4714 PyObject *resultobj = 0;
4715 int arg1 ;
4716 bool result;
4717 int val1 ;
4718 int ecode1 = 0 ;
4719 PyObject * obj0 = 0 ;
4720 char * kwnames[] = {
4721 (char *) "id", NULL
4722 };
4723
4724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4725 ecode1 = SWIG_AsVal_int(obj0, &val1);
4726 if (!SWIG_IsOK(ecode1)) {
4727 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4728 }
4729 arg1 = static_cast< int >(val1);
4730 {
4731 PyThreadState* __tstate = wxPyBeginAllowThreads();
4732 result = (bool)wxIsStockID(arg1);
4733 wxPyEndAllowThreads(__tstate);
4734 if (PyErr_Occurred()) SWIG_fail;
4735 }
4736 {
4737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4738 }
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj = 0;
4747 int arg1 ;
4748 wxString *arg2 = 0 ;
4749 bool result;
4750 int val1 ;
4751 int ecode1 = 0 ;
4752 bool temp2 = false ;
4753 PyObject * obj0 = 0 ;
4754 PyObject * obj1 = 0 ;
4755 char * kwnames[] = {
4756 (char *) "id",(char *) "label", NULL
4757 };
4758
4759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4760 ecode1 = SWIG_AsVal_int(obj0, &val1);
4761 if (!SWIG_IsOK(ecode1)) {
4762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4763 }
4764 arg1 = static_cast< int >(val1);
4765 {
4766 arg2 = wxString_in_helper(obj1);
4767 if (arg2 == NULL) SWIG_fail;
4768 temp2 = true;
4769 }
4770 {
4771 PyThreadState* __tstate = wxPyBeginAllowThreads();
4772 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4773 wxPyEndAllowThreads(__tstate);
4774 if (PyErr_Occurred()) SWIG_fail;
4775 }
4776 {
4777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4778 }
4779 {
4780 if (temp2)
4781 delete arg2;
4782 }
4783 return resultobj;
4784 fail:
4785 {
4786 if (temp2)
4787 delete arg2;
4788 }
4789 return NULL;
4790 }
4791
4792
4793 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4794 PyObject *resultobj = 0;
4795 int arg1 ;
4796 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4797 wxString result;
4798 int val1 ;
4799 int ecode1 = 0 ;
4800 long val2 ;
4801 int ecode2 = 0 ;
4802 PyObject * obj0 = 0 ;
4803 PyObject * obj1 = 0 ;
4804 char * kwnames[] = {
4805 (char *) "id",(char *) "flags", NULL
4806 };
4807
4808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4809 ecode1 = SWIG_AsVal_int(obj0, &val1);
4810 if (!SWIG_IsOK(ecode1)) {
4811 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4812 }
4813 arg1 = static_cast< int >(val1);
4814 if (obj1) {
4815 ecode2 = SWIG_AsVal_long(obj1, &val2);
4816 if (!SWIG_IsOK(ecode2)) {
4817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4818 }
4819 arg2 = static_cast< long >(val2);
4820 }
4821 {
4822 PyThreadState* __tstate = wxPyBeginAllowThreads();
4823 result = wxGetStockLabel(arg1,arg2);
4824 wxPyEndAllowThreads(__tstate);
4825 if (PyErr_Occurred()) SWIG_fail;
4826 }
4827 {
4828 #if wxUSE_UNICODE
4829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4830 #else
4831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4832 #endif
4833 }
4834 return resultobj;
4835 fail:
4836 return NULL;
4837 }
4838
4839
4840 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4841 PyObject *resultobj = 0;
4842 int arg1 ;
4843 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4844 wxString result;
4845 int val1 ;
4846 int ecode1 = 0 ;
4847 int val2 ;
4848 int ecode2 = 0 ;
4849 PyObject * obj0 = 0 ;
4850 PyObject * obj1 = 0 ;
4851 char * kwnames[] = {
4852 (char *) "id",(char *) "client", NULL
4853 };
4854
4855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4856 ecode1 = SWIG_AsVal_int(obj0, &val1);
4857 if (!SWIG_IsOK(ecode1)) {
4858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4859 }
4860 arg1 = static_cast< int >(val1);
4861 if (obj1) {
4862 ecode2 = SWIG_AsVal_int(obj1, &val2);
4863 if (!SWIG_IsOK(ecode2)) {
4864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4865 }
4866 arg2 = static_cast< wxStockHelpStringClient >(val2);
4867 }
4868 {
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 result = wxGetStockHelpString(arg1,arg2);
4871 wxPyEndAllowThreads(__tstate);
4872 if (PyErr_Occurred()) SWIG_fail;
4873 }
4874 {
4875 #if wxUSE_UNICODE
4876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4877 #else
4878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4879 #endif
4880 }
4881 return resultobj;
4882 fail:
4883 return NULL;
4884 }
4885
4886
4887 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4888 PyObject *resultobj = 0;
4889
4890 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4891 {
4892 if (!wxPyCheckForApp()) SWIG_fail;
4893 PyThreadState* __tstate = wxPyBeginAllowThreads();
4894 wxBell();
4895 wxPyEndAllowThreads(__tstate);
4896 if (PyErr_Occurred()) SWIG_fail;
4897 }
4898 resultobj = SWIG_Py_Void();
4899 return resultobj;
4900 fail:
4901 return NULL;
4902 }
4903
4904
4905 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4906 PyObject *resultobj = 0;
4907
4908 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4909 {
4910 if (!wxPyCheckForApp()) SWIG_fail;
4911 PyThreadState* __tstate = wxPyBeginAllowThreads();
4912 wxEndBusyCursor();
4913 wxPyEndAllowThreads(__tstate);
4914 if (PyErr_Occurred()) SWIG_fail;
4915 }
4916 resultobj = SWIG_Py_Void();
4917 return resultobj;
4918 fail:
4919 return NULL;
4920 }
4921
4922
4923 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4924 PyObject *resultobj = 0;
4925 bool arg1 = (bool) true ;
4926 long result;
4927 bool val1 ;
4928 int ecode1 = 0 ;
4929 PyObject * obj0 = 0 ;
4930 char * kwnames[] = {
4931 (char *) "resetTimer", NULL
4932 };
4933
4934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4935 if (obj0) {
4936 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4937 if (!SWIG_IsOK(ecode1)) {
4938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4939 }
4940 arg1 = static_cast< bool >(val1);
4941 }
4942 {
4943 PyThreadState* __tstate = wxPyBeginAllowThreads();
4944 result = (long)wxGetElapsedTime(arg1);
4945 wxPyEndAllowThreads(__tstate);
4946 if (PyErr_Occurred()) SWIG_fail;
4947 }
4948 resultobj = SWIG_From_long(static_cast< long >(result));
4949 return resultobj;
4950 fail:
4951 return NULL;
4952 }
4953
4954
4955 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4956 PyObject *resultobj = 0;
4957 bool result;
4958
4959 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4960 {
4961 PyThreadState* __tstate = wxPyBeginAllowThreads();
4962 result = (bool)wxIsBusy();
4963 wxPyEndAllowThreads(__tstate);
4964 if (PyErr_Occurred()) SWIG_fail;
4965 }
4966 {
4967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4968 }
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4976 PyObject *resultobj = 0;
4977 wxString result;
4978
4979 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4980 {
4981 PyThreadState* __tstate = wxPyBeginAllowThreads();
4982 result = wxNow();
4983 wxPyEndAllowThreads(__tstate);
4984 if (PyErr_Occurred()) SWIG_fail;
4985 }
4986 {
4987 #if wxUSE_UNICODE
4988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4989 #else
4990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4991 #endif
4992 }
4993 return resultobj;
4994 fail:
4995 return NULL;
4996 }
4997
4998
4999 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5000 PyObject *resultobj = 0;
5001 wxString const &arg1_defvalue = wxPyEmptyString ;
5002 wxString *arg1 = (wxString *) &arg1_defvalue ;
5003 bool result;
5004 bool temp1 = false ;
5005 PyObject * obj0 = 0 ;
5006 char * kwnames[] = {
5007 (char *) "command", NULL
5008 };
5009
5010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5011 if (obj0) {
5012 {
5013 arg1 = wxString_in_helper(obj0);
5014 if (arg1 == NULL) SWIG_fail;
5015 temp1 = true;
5016 }
5017 }
5018 {
5019 PyThreadState* __tstate = wxPyBeginAllowThreads();
5020 result = (bool)wxShell((wxString const &)*arg1);
5021 wxPyEndAllowThreads(__tstate);
5022 if (PyErr_Occurred()) SWIG_fail;
5023 }
5024 {
5025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5026 }
5027 {
5028 if (temp1)
5029 delete arg1;
5030 }
5031 return resultobj;
5032 fail:
5033 {
5034 if (temp1)
5035 delete arg1;
5036 }
5037 return NULL;
5038 }
5039
5040
5041 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5042 PyObject *resultobj = 0;
5043
5044 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5045 {
5046 PyThreadState* __tstate = wxPyBeginAllowThreads();
5047 wxStartTimer();
5048 wxPyEndAllowThreads(__tstate);
5049 if (PyErr_Occurred()) SWIG_fail;
5050 }
5051 resultobj = SWIG_Py_Void();
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5059 PyObject *resultobj = 0;
5060 int *arg1 = (int *) 0 ;
5061 int *arg2 = (int *) 0 ;
5062 int result;
5063 int temp1 ;
5064 int res1 = SWIG_TMPOBJ ;
5065 int temp2 ;
5066 int res2 = SWIG_TMPOBJ ;
5067
5068 arg1 = &temp1;
5069 arg2 = &temp2;
5070 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5071 {
5072 PyThreadState* __tstate = wxPyBeginAllowThreads();
5073 result = (int)wxGetOsVersion(arg1,arg2);
5074 wxPyEndAllowThreads(__tstate);
5075 if (PyErr_Occurred()) SWIG_fail;
5076 }
5077 resultobj = SWIG_From_int(static_cast< int >(result));
5078 if (SWIG_IsTmpObj(res1)) {
5079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5080 } else {
5081 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5083 }
5084 if (SWIG_IsTmpObj(res2)) {
5085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5086 } else {
5087 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5089 }
5090 return resultobj;
5091 fail:
5092 return NULL;
5093 }
5094
5095
5096 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5097 PyObject *resultobj = 0;
5098 wxString result;
5099
5100 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5101 {
5102 PyThreadState* __tstate = wxPyBeginAllowThreads();
5103 result = wxGetOsDescription();
5104 wxPyEndAllowThreads(__tstate);
5105 if (PyErr_Occurred()) SWIG_fail;
5106 }
5107 {
5108 #if wxUSE_UNICODE
5109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5110 #else
5111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5112 #endif
5113 }
5114 return resultobj;
5115 fail:
5116 return NULL;
5117 }
5118
5119
5120 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 PyObject *resultobj = 0;
5122 bool result;
5123
5124 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5125 {
5126 PyThreadState* __tstate = wxPyBeginAllowThreads();
5127 result = (bool)wxIsPlatformLittleEndian();
5128 wxPyEndAllowThreads(__tstate);
5129 if (PyErr_Occurred()) SWIG_fail;
5130 }
5131 {
5132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5133 }
5134 return resultobj;
5135 fail:
5136 return NULL;
5137 }
5138
5139
5140 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5141 PyObject *resultobj = 0;
5142 bool result;
5143
5144 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5145 {
5146 PyThreadState* __tstate = wxPyBeginAllowThreads();
5147 result = (bool)wxIsPlatform64Bit();
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 {
5152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5153 }
5154 return resultobj;
5155 fail:
5156 return NULL;
5157 }
5158
5159
5160 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5161 PyObject *resultobj = 0;
5162 wxMemorySize result;
5163
5164 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5165 {
5166 PyThreadState* __tstate = wxPyBeginAllowThreads();
5167 result = wxGetFreeMemory();
5168 wxPyEndAllowThreads(__tstate);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 {
5172 #if wxUSE_LONGLONG
5173 resultobj = PyLong_FromLongLong((&result)->GetValue());
5174 #else
5175 resultobj = PyInt_FromLong(result);
5176 #endif
5177 }
5178 return resultobj;
5179 fail:
5180 return NULL;
5181 }
5182
5183
5184 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5185 PyObject *resultobj = 0;
5186 wxShutdownFlags arg1 ;
5187 bool result;
5188 int val1 ;
5189 int ecode1 = 0 ;
5190 PyObject * obj0 = 0 ;
5191 char * kwnames[] = {
5192 (char *) "wFlags", NULL
5193 };
5194
5195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5196 ecode1 = SWIG_AsVal_int(obj0, &val1);
5197 if (!SWIG_IsOK(ecode1)) {
5198 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5199 }
5200 arg1 = static_cast< wxShutdownFlags >(val1);
5201 {
5202 if (!wxPyCheckForApp()) SWIG_fail;
5203 PyThreadState* __tstate = wxPyBeginAllowThreads();
5204 result = (bool)wxShutdown(arg1);
5205 wxPyEndAllowThreads(__tstate);
5206 if (PyErr_Occurred()) SWIG_fail;
5207 }
5208 {
5209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5210 }
5211 return resultobj;
5212 fail:
5213 return NULL;
5214 }
5215
5216
5217 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5218 PyObject *resultobj = 0;
5219 int arg1 ;
5220 int val1 ;
5221 int ecode1 = 0 ;
5222 PyObject * obj0 = 0 ;
5223 char * kwnames[] = {
5224 (char *) "secs", NULL
5225 };
5226
5227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5228 ecode1 = SWIG_AsVal_int(obj0, &val1);
5229 if (!SWIG_IsOK(ecode1)) {
5230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5231 }
5232 arg1 = static_cast< int >(val1);
5233 {
5234 PyThreadState* __tstate = wxPyBeginAllowThreads();
5235 wxSleep(arg1);
5236 wxPyEndAllowThreads(__tstate);
5237 if (PyErr_Occurred()) SWIG_fail;
5238 }
5239 resultobj = SWIG_Py_Void();
5240 return resultobj;
5241 fail:
5242 return NULL;
5243 }
5244
5245
5246 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5247 PyObject *resultobj = 0;
5248 unsigned long arg1 ;
5249 unsigned long val1 ;
5250 int ecode1 = 0 ;
5251 PyObject * obj0 = 0 ;
5252 char * kwnames[] = {
5253 (char *) "milliseconds", NULL
5254 };
5255
5256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5257 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5258 if (!SWIG_IsOK(ecode1)) {
5259 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5260 }
5261 arg1 = static_cast< unsigned long >(val1);
5262 {
5263 PyThreadState* __tstate = wxPyBeginAllowThreads();
5264 wxMilliSleep(arg1);
5265 wxPyEndAllowThreads(__tstate);
5266 if (PyErr_Occurred()) SWIG_fail;
5267 }
5268 resultobj = SWIG_Py_Void();
5269 return resultobj;
5270 fail:
5271 return NULL;
5272 }
5273
5274
5275 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5276 PyObject *resultobj = 0;
5277 unsigned long arg1 ;
5278 unsigned long val1 ;
5279 int ecode1 = 0 ;
5280 PyObject * obj0 = 0 ;
5281 char * kwnames[] = {
5282 (char *) "microseconds", NULL
5283 };
5284
5285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5286 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5287 if (!SWIG_IsOK(ecode1)) {
5288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5289 }
5290 arg1 = static_cast< unsigned long >(val1);
5291 {
5292 PyThreadState* __tstate = wxPyBeginAllowThreads();
5293 wxMicroSleep(arg1);
5294 wxPyEndAllowThreads(__tstate);
5295 if (PyErr_Occurred()) SWIG_fail;
5296 }
5297 resultobj = SWIG_Py_Void();
5298 return resultobj;
5299 fail:
5300 return NULL;
5301 }
5302
5303
5304 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5305 PyObject *resultobj = 0;
5306 bool arg1 ;
5307 bool val1 ;
5308 int ecode1 = 0 ;
5309 PyObject * obj0 = 0 ;
5310 char * kwnames[] = {
5311 (char *) "enable", NULL
5312 };
5313
5314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5315 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5316 if (!SWIG_IsOK(ecode1)) {
5317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5318 }
5319 arg1 = static_cast< bool >(val1);
5320 {
5321 PyThreadState* __tstate = wxPyBeginAllowThreads();
5322 wxEnableTopLevelWindows(arg1);
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 resultobj = SWIG_Py_Void();
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5334 PyObject *resultobj = 0;
5335 wxString *arg1 = 0 ;
5336 wxString result;
5337 bool temp1 = false ;
5338 PyObject * obj0 = 0 ;
5339 char * kwnames[] = {
5340 (char *) "in", NULL
5341 };
5342
5343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5344 {
5345 arg1 = wxString_in_helper(obj0);
5346 if (arg1 == NULL) SWIG_fail;
5347 temp1 = true;
5348 }
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 result = wxStripMenuCodes((wxString const &)*arg1);
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 {
5356 #if wxUSE_UNICODE
5357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5358 #else
5359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5360 #endif
5361 }
5362 {
5363 if (temp1)
5364 delete arg1;
5365 }
5366 return resultobj;
5367 fail:
5368 {
5369 if (temp1)
5370 delete arg1;
5371 }
5372 return NULL;
5373 }
5374
5375
5376 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5377 PyObject *resultobj = 0;
5378 wxString result;
5379
5380 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5381 {
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 result = wxGetEmailAddress();
5384 wxPyEndAllowThreads(__tstate);
5385 if (PyErr_Occurred()) SWIG_fail;
5386 }
5387 {
5388 #if wxUSE_UNICODE
5389 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5390 #else
5391 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5392 #endif
5393 }
5394 return resultobj;
5395 fail:
5396 return NULL;
5397 }
5398
5399
5400 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5401 PyObject *resultobj = 0;
5402 wxString result;
5403
5404 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5405 {
5406 PyThreadState* __tstate = wxPyBeginAllowThreads();
5407 result = wxGetHostName();
5408 wxPyEndAllowThreads(__tstate);
5409 if (PyErr_Occurred()) SWIG_fail;
5410 }
5411 {
5412 #if wxUSE_UNICODE
5413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5414 #else
5415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5416 #endif
5417 }
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5425 PyObject *resultobj = 0;
5426 wxString result;
5427
5428 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5429 {
5430 PyThreadState* __tstate = wxPyBeginAllowThreads();
5431 result = wxGetFullHostName();
5432 wxPyEndAllowThreads(__tstate);
5433 if (PyErr_Occurred()) SWIG_fail;
5434 }
5435 {
5436 #if wxUSE_UNICODE
5437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5438 #else
5439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5440 #endif
5441 }
5442 return resultobj;
5443 fail:
5444 return NULL;
5445 }
5446
5447
5448 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5449 PyObject *resultobj = 0;
5450 wxString result;
5451
5452 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5453 {
5454 PyThreadState* __tstate = wxPyBeginAllowThreads();
5455 result = wxGetUserId();
5456 wxPyEndAllowThreads(__tstate);
5457 if (PyErr_Occurred()) SWIG_fail;
5458 }
5459 {
5460 #if wxUSE_UNICODE
5461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5462 #else
5463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5464 #endif
5465 }
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5473 PyObject *resultobj = 0;
5474 wxString result;
5475
5476 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5477 {
5478 PyThreadState* __tstate = wxPyBeginAllowThreads();
5479 result = wxGetUserName();
5480 wxPyEndAllowThreads(__tstate);
5481 if (PyErr_Occurred()) SWIG_fail;
5482 }
5483 {
5484 #if wxUSE_UNICODE
5485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5486 #else
5487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5488 #endif
5489 }
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5497 PyObject *resultobj = 0;
5498 wxString result;
5499
5500 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5501 {
5502 PyThreadState* __tstate = wxPyBeginAllowThreads();
5503 result = wxGetHomeDir();
5504 wxPyEndAllowThreads(__tstate);
5505 if (PyErr_Occurred()) SWIG_fail;
5506 }
5507 {
5508 #if wxUSE_UNICODE
5509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5510 #else
5511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5512 #endif
5513 }
5514 return resultobj;
5515 fail:
5516 return NULL;
5517 }
5518
5519
5520 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5521 PyObject *resultobj = 0;
5522 wxString const &arg1_defvalue = wxPyEmptyString ;
5523 wxString *arg1 = (wxString *) &arg1_defvalue ;
5524 wxString result;
5525 bool temp1 = false ;
5526 PyObject * obj0 = 0 ;
5527 char * kwnames[] = {
5528 (char *) "user", NULL
5529 };
5530
5531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5532 if (obj0) {
5533 {
5534 arg1 = wxString_in_helper(obj0);
5535 if (arg1 == NULL) SWIG_fail;
5536 temp1 = true;
5537 }
5538 }
5539 {
5540 PyThreadState* __tstate = wxPyBeginAllowThreads();
5541 result = wxGetUserHome((wxString const &)*arg1);
5542 wxPyEndAllowThreads(__tstate);
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 {
5546 #if wxUSE_UNICODE
5547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5548 #else
5549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5550 #endif
5551 }
5552 {
5553 if (temp1)
5554 delete arg1;
5555 }
5556 return resultobj;
5557 fail:
5558 {
5559 if (temp1)
5560 delete arg1;
5561 }
5562 return NULL;
5563 }
5564
5565
5566 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5567 PyObject *resultobj = 0;
5568 unsigned long result;
5569
5570 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5571 {
5572 PyThreadState* __tstate = wxPyBeginAllowThreads();
5573 result = (unsigned long)wxGetProcessId();
5574 wxPyEndAllowThreads(__tstate);
5575 if (PyErr_Occurred()) SWIG_fail;
5576 }
5577 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5578 return resultobj;
5579 fail:
5580 return NULL;
5581 }
5582
5583
5584 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 PyObject *resultobj = 0;
5586
5587 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5588 {
5589 PyThreadState* __tstate = wxPyBeginAllowThreads();
5590 wxTrap();
5591 wxPyEndAllowThreads(__tstate);
5592 if (PyErr_Occurred()) SWIG_fail;
5593 }
5594 resultobj = SWIG_Py_Void();
5595 return resultobj;
5596 fail:
5597 return NULL;
5598 }
5599
5600
5601 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5602 PyObject *resultobj = 0;
5603 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5604 wxString *arg1 = (wxString *) &arg1_defvalue ;
5605 wxString const &arg2_defvalue = wxPyEmptyString ;
5606 wxString *arg2 = (wxString *) &arg2_defvalue ;
5607 wxString const &arg3_defvalue = wxPyEmptyString ;
5608 wxString *arg3 = (wxString *) &arg3_defvalue ;
5609 wxString const &arg4_defvalue = wxPyEmptyString ;
5610 wxString *arg4 = (wxString *) &arg4_defvalue ;
5611 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5612 wxString *arg5 = (wxString *) &arg5_defvalue ;
5613 int arg6 = (int) 0 ;
5614 wxWindow *arg7 = (wxWindow *) NULL ;
5615 int arg8 = (int) -1 ;
5616 int arg9 = (int) -1 ;
5617 wxString result;
5618 bool temp1 = false ;
5619 bool temp2 = false ;
5620 bool temp3 = false ;
5621 bool temp4 = false ;
5622 bool temp5 = false ;
5623 int val6 ;
5624 int ecode6 = 0 ;
5625 void *argp7 = 0 ;
5626 int res7 = 0 ;
5627 int val8 ;
5628 int ecode8 = 0 ;
5629 int val9 ;
5630 int ecode9 = 0 ;
5631 PyObject * obj0 = 0 ;
5632 PyObject * obj1 = 0 ;
5633 PyObject * obj2 = 0 ;
5634 PyObject * obj3 = 0 ;
5635 PyObject * obj4 = 0 ;
5636 PyObject * obj5 = 0 ;
5637 PyObject * obj6 = 0 ;
5638 PyObject * obj7 = 0 ;
5639 PyObject * obj8 = 0 ;
5640 char * kwnames[] = {
5641 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5642 };
5643
5644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5645 if (obj0) {
5646 {
5647 arg1 = wxString_in_helper(obj0);
5648 if (arg1 == NULL) SWIG_fail;
5649 temp1 = true;
5650 }
5651 }
5652 if (obj1) {
5653 {
5654 arg2 = wxString_in_helper(obj1);
5655 if (arg2 == NULL) SWIG_fail;
5656 temp2 = true;
5657 }
5658 }
5659 if (obj2) {
5660 {
5661 arg3 = wxString_in_helper(obj2);
5662 if (arg3 == NULL) SWIG_fail;
5663 temp3 = true;
5664 }
5665 }
5666 if (obj3) {
5667 {
5668 arg4 = wxString_in_helper(obj3);
5669 if (arg4 == NULL) SWIG_fail;
5670 temp4 = true;
5671 }
5672 }
5673 if (obj4) {
5674 {
5675 arg5 = wxString_in_helper(obj4);
5676 if (arg5 == NULL) SWIG_fail;
5677 temp5 = true;
5678 }
5679 }
5680 if (obj5) {
5681 ecode6 = SWIG_AsVal_int(obj5, &val6);
5682 if (!SWIG_IsOK(ecode6)) {
5683 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5684 }
5685 arg6 = static_cast< int >(val6);
5686 }
5687 if (obj6) {
5688 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5689 if (!SWIG_IsOK(res7)) {
5690 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5691 }
5692 arg7 = reinterpret_cast< wxWindow * >(argp7);
5693 }
5694 if (obj7) {
5695 ecode8 = SWIG_AsVal_int(obj7, &val8);
5696 if (!SWIG_IsOK(ecode8)) {
5697 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5698 }
5699 arg8 = static_cast< int >(val8);
5700 }
5701 if (obj8) {
5702 ecode9 = SWIG_AsVal_int(obj8, &val9);
5703 if (!SWIG_IsOK(ecode9)) {
5704 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5705 }
5706 arg9 = static_cast< int >(val9);
5707 }
5708 {
5709 if (!wxPyCheckForApp()) SWIG_fail;
5710 PyThreadState* __tstate = wxPyBeginAllowThreads();
5711 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5712 wxPyEndAllowThreads(__tstate);
5713 if (PyErr_Occurred()) SWIG_fail;
5714 }
5715 {
5716 #if wxUSE_UNICODE
5717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5718 #else
5719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5720 #endif
5721 }
5722 {
5723 if (temp1)
5724 delete arg1;
5725 }
5726 {
5727 if (temp2)
5728 delete arg2;
5729 }
5730 {
5731 if (temp3)
5732 delete arg3;
5733 }
5734 {
5735 if (temp4)
5736 delete arg4;
5737 }
5738 {
5739 if (temp5)
5740 delete arg5;
5741 }
5742 return resultobj;
5743 fail:
5744 {
5745 if (temp1)
5746 delete arg1;
5747 }
5748 {
5749 if (temp2)
5750 delete arg2;
5751 }
5752 {
5753 if (temp3)
5754 delete arg3;
5755 }
5756 {
5757 if (temp4)
5758 delete arg4;
5759 }
5760 {
5761 if (temp5)
5762 delete arg5;
5763 }
5764 return NULL;
5765 }
5766
5767
5768 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj = 0;
5770 wxString *arg1 = 0 ;
5771 wxString *arg2 = 0 ;
5772 wxString const &arg3_defvalue = wxPyEmptyString ;
5773 wxString *arg3 = (wxString *) &arg3_defvalue ;
5774 wxWindow *arg4 = (wxWindow *) NULL ;
5775 wxString result;
5776 bool temp1 = false ;
5777 bool temp2 = false ;
5778 bool temp3 = false ;
5779 void *argp4 = 0 ;
5780 int res4 = 0 ;
5781 PyObject * obj0 = 0 ;
5782 PyObject * obj1 = 0 ;
5783 PyObject * obj2 = 0 ;
5784 PyObject * obj3 = 0 ;
5785 char * kwnames[] = {
5786 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5787 };
5788
5789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5790 {
5791 arg1 = wxString_in_helper(obj0);
5792 if (arg1 == NULL) SWIG_fail;
5793 temp1 = true;
5794 }
5795 {
5796 arg2 = wxString_in_helper(obj1);
5797 if (arg2 == NULL) SWIG_fail;
5798 temp2 = true;
5799 }
5800 if (obj2) {
5801 {
5802 arg3 = wxString_in_helper(obj2);
5803 if (arg3 == NULL) SWIG_fail;
5804 temp3 = true;
5805 }
5806 }
5807 if (obj3) {
5808 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5809 if (!SWIG_IsOK(res4)) {
5810 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5811 }
5812 arg4 = reinterpret_cast< wxWindow * >(argp4);
5813 }
5814 {
5815 if (!wxPyCheckForApp()) SWIG_fail;
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5818 wxPyEndAllowThreads(__tstate);
5819 if (PyErr_Occurred()) SWIG_fail;
5820 }
5821 {
5822 #if wxUSE_UNICODE
5823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5824 #else
5825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5826 #endif
5827 }
5828 {
5829 if (temp1)
5830 delete arg1;
5831 }
5832 {
5833 if (temp2)
5834 delete arg2;
5835 }
5836 {
5837 if (temp3)
5838 delete arg3;
5839 }
5840 return resultobj;
5841 fail:
5842 {
5843 if (temp1)
5844 delete arg1;
5845 }
5846 {
5847 if (temp2)
5848 delete arg2;
5849 }
5850 {
5851 if (temp3)
5852 delete arg3;
5853 }
5854 return NULL;
5855 }
5856
5857
5858 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj = 0;
5860 wxString *arg1 = 0 ;
5861 wxString *arg2 = 0 ;
5862 wxString const &arg3_defvalue = wxPyEmptyString ;
5863 wxString *arg3 = (wxString *) &arg3_defvalue ;
5864 wxWindow *arg4 = (wxWindow *) NULL ;
5865 wxString result;
5866 bool temp1 = false ;
5867 bool temp2 = false ;
5868 bool temp3 = false ;
5869 void *argp4 = 0 ;
5870 int res4 = 0 ;
5871 PyObject * obj0 = 0 ;
5872 PyObject * obj1 = 0 ;
5873 PyObject * obj2 = 0 ;
5874 PyObject * obj3 = 0 ;
5875 char * kwnames[] = {
5876 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5877 };
5878
5879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5880 {
5881 arg1 = wxString_in_helper(obj0);
5882 if (arg1 == NULL) SWIG_fail;
5883 temp1 = true;
5884 }
5885 {
5886 arg2 = wxString_in_helper(obj1);
5887 if (arg2 == NULL) SWIG_fail;
5888 temp2 = true;
5889 }
5890 if (obj2) {
5891 {
5892 arg3 = wxString_in_helper(obj2);
5893 if (arg3 == NULL) SWIG_fail;
5894 temp3 = true;
5895 }
5896 }
5897 if (obj3) {
5898 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5899 if (!SWIG_IsOK(res4)) {
5900 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5901 }
5902 arg4 = reinterpret_cast< wxWindow * >(argp4);
5903 }
5904 {
5905 if (!wxPyCheckForApp()) SWIG_fail;
5906 PyThreadState* __tstate = wxPyBeginAllowThreads();
5907 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5908 wxPyEndAllowThreads(__tstate);
5909 if (PyErr_Occurred()) SWIG_fail;
5910 }
5911 {
5912 #if wxUSE_UNICODE
5913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5914 #else
5915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5916 #endif
5917 }
5918 {
5919 if (temp1)
5920 delete arg1;
5921 }
5922 {
5923 if (temp2)
5924 delete arg2;
5925 }
5926 {
5927 if (temp3)
5928 delete arg3;
5929 }
5930 return resultobj;
5931 fail:
5932 {
5933 if (temp1)
5934 delete arg1;
5935 }
5936 {
5937 if (temp2)
5938 delete arg2;
5939 }
5940 {
5941 if (temp3)
5942 delete arg3;
5943 }
5944 return NULL;
5945 }
5946
5947
5948 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5949 PyObject *resultobj = 0;
5950 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5951 wxString *arg1 = (wxString *) &arg1_defvalue ;
5952 wxString const &arg2_defvalue = wxPyEmptyString ;
5953 wxString *arg2 = (wxString *) &arg2_defvalue ;
5954 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5955 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5956 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5957 wxWindow *arg5 = (wxWindow *) NULL ;
5958 wxString result;
5959 bool temp1 = false ;
5960 bool temp2 = false ;
5961 long val3 ;
5962 int ecode3 = 0 ;
5963 wxPoint temp4 ;
5964 void *argp5 = 0 ;
5965 int res5 = 0 ;
5966 PyObject * obj0 = 0 ;
5967 PyObject * obj1 = 0 ;
5968 PyObject * obj2 = 0 ;
5969 PyObject * obj3 = 0 ;
5970 PyObject * obj4 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5976 if (obj0) {
5977 {
5978 arg1 = wxString_in_helper(obj0);
5979 if (arg1 == NULL) SWIG_fail;
5980 temp1 = true;
5981 }
5982 }
5983 if (obj1) {
5984 {
5985 arg2 = wxString_in_helper(obj1);
5986 if (arg2 == NULL) SWIG_fail;
5987 temp2 = true;
5988 }
5989 }
5990 if (obj2) {
5991 ecode3 = SWIG_AsVal_long(obj2, &val3);
5992 if (!SWIG_IsOK(ecode3)) {
5993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5994 }
5995 arg3 = static_cast< long >(val3);
5996 }
5997 if (obj3) {
5998 {
5999 arg4 = &temp4;
6000 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6001 }
6002 }
6003 if (obj4) {
6004 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6005 if (!SWIG_IsOK(res5)) {
6006 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6007 }
6008 arg5 = reinterpret_cast< wxWindow * >(argp5);
6009 }
6010 {
6011 if (!wxPyCheckForApp()) SWIG_fail;
6012 PyThreadState* __tstate = wxPyBeginAllowThreads();
6013 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6014 wxPyEndAllowThreads(__tstate);
6015 if (PyErr_Occurred()) SWIG_fail;
6016 }
6017 {
6018 #if wxUSE_UNICODE
6019 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6020 #else
6021 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6022 #endif
6023 }
6024 {
6025 if (temp1)
6026 delete arg1;
6027 }
6028 {
6029 if (temp2)
6030 delete arg2;
6031 }
6032 return resultobj;
6033 fail:
6034 {
6035 if (temp1)
6036 delete arg1;
6037 }
6038 {
6039 if (temp2)
6040 delete arg2;
6041 }
6042 return NULL;
6043 }
6044
6045
6046 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6047 PyObject *resultobj = 0;
6048 wxString *arg1 = 0 ;
6049 wxString const &arg2_defvalue = wxPyEmptyString ;
6050 wxString *arg2 = (wxString *) &arg2_defvalue ;
6051 wxString const &arg3_defvalue = wxPyEmptyString ;
6052 wxString *arg3 = (wxString *) &arg3_defvalue ;
6053 wxWindow *arg4 = (wxWindow *) NULL ;
6054 int arg5 = (int) -1 ;
6055 int arg6 = (int) -1 ;
6056 bool arg7 = (bool) true ;
6057 wxString result;
6058 bool temp1 = false ;
6059 bool temp2 = false ;
6060 bool temp3 = false ;
6061 void *argp4 = 0 ;
6062 int res4 = 0 ;
6063 int val5 ;
6064 int ecode5 = 0 ;
6065 int val6 ;
6066 int ecode6 = 0 ;
6067 bool val7 ;
6068 int ecode7 = 0 ;
6069 PyObject * obj0 = 0 ;
6070 PyObject * obj1 = 0 ;
6071 PyObject * obj2 = 0 ;
6072 PyObject * obj3 = 0 ;
6073 PyObject * obj4 = 0 ;
6074 PyObject * obj5 = 0 ;
6075 PyObject * obj6 = 0 ;
6076 char * kwnames[] = {
6077 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6078 };
6079
6080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6081 {
6082 arg1 = wxString_in_helper(obj0);
6083 if (arg1 == NULL) SWIG_fail;
6084 temp1 = true;
6085 }
6086 if (obj1) {
6087 {
6088 arg2 = wxString_in_helper(obj1);
6089 if (arg2 == NULL) SWIG_fail;
6090 temp2 = true;
6091 }
6092 }
6093 if (obj2) {
6094 {
6095 arg3 = wxString_in_helper(obj2);
6096 if (arg3 == NULL) SWIG_fail;
6097 temp3 = true;
6098 }
6099 }
6100 if (obj3) {
6101 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6102 if (!SWIG_IsOK(res4)) {
6103 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6104 }
6105 arg4 = reinterpret_cast< wxWindow * >(argp4);
6106 }
6107 if (obj4) {
6108 ecode5 = SWIG_AsVal_int(obj4, &val5);
6109 if (!SWIG_IsOK(ecode5)) {
6110 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6111 }
6112 arg5 = static_cast< int >(val5);
6113 }
6114 if (obj5) {
6115 ecode6 = SWIG_AsVal_int(obj5, &val6);
6116 if (!SWIG_IsOK(ecode6)) {
6117 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6118 }
6119 arg6 = static_cast< int >(val6);
6120 }
6121 if (obj6) {
6122 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6123 if (!SWIG_IsOK(ecode7)) {
6124 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6125 }
6126 arg7 = static_cast< bool >(val7);
6127 }
6128 {
6129 if (!wxPyCheckForApp()) SWIG_fail;
6130 PyThreadState* __tstate = wxPyBeginAllowThreads();
6131 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6132 wxPyEndAllowThreads(__tstate);
6133 if (PyErr_Occurred()) SWIG_fail;
6134 }
6135 {
6136 #if wxUSE_UNICODE
6137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6138 #else
6139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6140 #endif
6141 }
6142 {
6143 if (temp1)
6144 delete arg1;
6145 }
6146 {
6147 if (temp2)
6148 delete arg2;
6149 }
6150 {
6151 if (temp3)
6152 delete arg3;
6153 }
6154 return resultobj;
6155 fail:
6156 {
6157 if (temp1)
6158 delete arg1;
6159 }
6160 {
6161 if (temp2)
6162 delete arg2;
6163 }
6164 {
6165 if (temp3)
6166 delete arg3;
6167 }
6168 return NULL;
6169 }
6170
6171
6172 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6173 PyObject *resultobj = 0;
6174 wxString *arg1 = 0 ;
6175 wxString const &arg2_defvalue = wxPyEmptyString ;
6176 wxString *arg2 = (wxString *) &arg2_defvalue ;
6177 wxString const &arg3_defvalue = wxPyEmptyString ;
6178 wxString *arg3 = (wxString *) &arg3_defvalue ;
6179 wxWindow *arg4 = (wxWindow *) NULL ;
6180 wxString result;
6181 bool temp1 = false ;
6182 bool temp2 = false ;
6183 bool temp3 = false ;
6184 void *argp4 = 0 ;
6185 int res4 = 0 ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 PyObject * obj2 = 0 ;
6189 PyObject * obj3 = 0 ;
6190 char * kwnames[] = {
6191 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6192 };
6193
6194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6195 {
6196 arg1 = wxString_in_helper(obj0);
6197 if (arg1 == NULL) SWIG_fail;
6198 temp1 = true;
6199 }
6200 if (obj1) {
6201 {
6202 arg2 = wxString_in_helper(obj1);
6203 if (arg2 == NULL) SWIG_fail;
6204 temp2 = true;
6205 }
6206 }
6207 if (obj2) {
6208 {
6209 arg3 = wxString_in_helper(obj2);
6210 if (arg3 == NULL) SWIG_fail;
6211 temp3 = true;
6212 }
6213 }
6214 if (obj3) {
6215 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6216 if (!SWIG_IsOK(res4)) {
6217 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6218 }
6219 arg4 = reinterpret_cast< wxWindow * >(argp4);
6220 }
6221 {
6222 if (!wxPyCheckForApp()) SWIG_fail;
6223 PyThreadState* __tstate = wxPyBeginAllowThreads();
6224 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6225 wxPyEndAllowThreads(__tstate);
6226 if (PyErr_Occurred()) SWIG_fail;
6227 }
6228 {
6229 #if wxUSE_UNICODE
6230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6231 #else
6232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6233 #endif
6234 }
6235 {
6236 if (temp1)
6237 delete arg1;
6238 }
6239 {
6240 if (temp2)
6241 delete arg2;
6242 }
6243 {
6244 if (temp3)
6245 delete arg3;
6246 }
6247 return resultobj;
6248 fail:
6249 {
6250 if (temp1)
6251 delete arg1;
6252 }
6253 {
6254 if (temp2)
6255 delete arg2;
6256 }
6257 {
6258 if (temp3)
6259 delete arg3;
6260 }
6261 return NULL;
6262 }
6263
6264
6265 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj = 0;
6267 wxString *arg1 = 0 ;
6268 wxString *arg2 = 0 ;
6269 int arg3 ;
6270 wxString *arg4 = (wxString *) 0 ;
6271 wxWindow *arg5 = (wxWindow *) NULL ;
6272 int arg6 = (int) -1 ;
6273 int arg7 = (int) -1 ;
6274 bool arg8 = (bool) true ;
6275 int arg9 = (int) 150 ;
6276 int arg10 = (int) 200 ;
6277 wxString result;
6278 bool temp1 = false ;
6279 bool temp2 = false ;
6280 void *argp5 = 0 ;
6281 int res5 = 0 ;
6282 int val6 ;
6283 int ecode6 = 0 ;
6284 int val7 ;
6285 int ecode7 = 0 ;
6286 bool val8 ;
6287 int ecode8 = 0 ;
6288 int val9 ;
6289 int ecode9 = 0 ;
6290 int val10 ;
6291 int ecode10 = 0 ;
6292 PyObject * obj0 = 0 ;
6293 PyObject * obj1 = 0 ;
6294 PyObject * obj2 = 0 ;
6295 PyObject * obj3 = 0 ;
6296 PyObject * obj4 = 0 ;
6297 PyObject * obj5 = 0 ;
6298 PyObject * obj6 = 0 ;
6299 PyObject * obj7 = 0 ;
6300 PyObject * obj8 = 0 ;
6301 char * kwnames[] = {
6302 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6303 };
6304
6305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6306 {
6307 arg1 = wxString_in_helper(obj0);
6308 if (arg1 == NULL) SWIG_fail;
6309 temp1 = true;
6310 }
6311 {
6312 arg2 = wxString_in_helper(obj1);
6313 if (arg2 == NULL) SWIG_fail;
6314 temp2 = true;
6315 }
6316 {
6317 arg3 = PyList_Size(obj2);
6318 arg4 = wxString_LIST_helper(obj2);
6319 if (arg4 == NULL) SWIG_fail;
6320 }
6321 if (obj3) {
6322 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6323 if (!SWIG_IsOK(res5)) {
6324 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6325 }
6326 arg5 = reinterpret_cast< wxWindow * >(argp5);
6327 }
6328 if (obj4) {
6329 ecode6 = SWIG_AsVal_int(obj4, &val6);
6330 if (!SWIG_IsOK(ecode6)) {
6331 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6332 }
6333 arg6 = static_cast< int >(val6);
6334 }
6335 if (obj5) {
6336 ecode7 = SWIG_AsVal_int(obj5, &val7);
6337 if (!SWIG_IsOK(ecode7)) {
6338 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6339 }
6340 arg7 = static_cast< int >(val7);
6341 }
6342 if (obj6) {
6343 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6344 if (!SWIG_IsOK(ecode8)) {
6345 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6346 }
6347 arg8 = static_cast< bool >(val8);
6348 }
6349 if (obj7) {
6350 ecode9 = SWIG_AsVal_int(obj7, &val9);
6351 if (!SWIG_IsOK(ecode9)) {
6352 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6353 }
6354 arg9 = static_cast< int >(val9);
6355 }
6356 if (obj8) {
6357 ecode10 = SWIG_AsVal_int(obj8, &val10);
6358 if (!SWIG_IsOK(ecode10)) {
6359 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6360 }
6361 arg10 = static_cast< int >(val10);
6362 }
6363 {
6364 if (!wxPyCheckForApp()) SWIG_fail;
6365 PyThreadState* __tstate = wxPyBeginAllowThreads();
6366 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6367 wxPyEndAllowThreads(__tstate);
6368 if (PyErr_Occurred()) SWIG_fail;
6369 }
6370 {
6371 #if wxUSE_UNICODE
6372 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6373 #else
6374 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6375 #endif
6376 }
6377 {
6378 if (temp1)
6379 delete arg1;
6380 }
6381 {
6382 if (temp2)
6383 delete arg2;
6384 }
6385 {
6386 if (arg4) delete [] arg4;
6387 }
6388 return resultobj;
6389 fail:
6390 {
6391 if (temp1)
6392 delete arg1;
6393 }
6394 {
6395 if (temp2)
6396 delete arg2;
6397 }
6398 {
6399 if (arg4) delete [] arg4;
6400 }
6401 return NULL;
6402 }
6403
6404
6405 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6406 PyObject *resultobj = 0;
6407 wxString *arg1 = 0 ;
6408 wxString *arg2 = 0 ;
6409 int arg3 ;
6410 wxString *arg4 = (wxString *) 0 ;
6411 wxWindow *arg5 = (wxWindow *) NULL ;
6412 int arg6 = (int) -1 ;
6413 int arg7 = (int) -1 ;
6414 bool arg8 = (bool) true ;
6415 int arg9 = (int) 150 ;
6416 int arg10 = (int) 200 ;
6417 int result;
6418 bool temp1 = false ;
6419 bool temp2 = false ;
6420 void *argp5 = 0 ;
6421 int res5 = 0 ;
6422 int val6 ;
6423 int ecode6 = 0 ;
6424 int val7 ;
6425 int ecode7 = 0 ;
6426 bool val8 ;
6427 int ecode8 = 0 ;
6428 int val9 ;
6429 int ecode9 = 0 ;
6430 int val10 ;
6431 int ecode10 = 0 ;
6432 PyObject * obj0 = 0 ;
6433 PyObject * obj1 = 0 ;
6434 PyObject * obj2 = 0 ;
6435 PyObject * obj3 = 0 ;
6436 PyObject * obj4 = 0 ;
6437 PyObject * obj5 = 0 ;
6438 PyObject * obj6 = 0 ;
6439 PyObject * obj7 = 0 ;
6440 PyObject * obj8 = 0 ;
6441 char * kwnames[] = {
6442 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6443 };
6444
6445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6446 {
6447 arg1 = wxString_in_helper(obj0);
6448 if (arg1 == NULL) SWIG_fail;
6449 temp1 = true;
6450 }
6451 {
6452 arg2 = wxString_in_helper(obj1);
6453 if (arg2 == NULL) SWIG_fail;
6454 temp2 = true;
6455 }
6456 {
6457 arg3 = PyList_Size(obj2);
6458 arg4 = wxString_LIST_helper(obj2);
6459 if (arg4 == NULL) SWIG_fail;
6460 }
6461 if (obj3) {
6462 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6463 if (!SWIG_IsOK(res5)) {
6464 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6465 }
6466 arg5 = reinterpret_cast< wxWindow * >(argp5);
6467 }
6468 if (obj4) {
6469 ecode6 = SWIG_AsVal_int(obj4, &val6);
6470 if (!SWIG_IsOK(ecode6)) {
6471 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6472 }
6473 arg6 = static_cast< int >(val6);
6474 }
6475 if (obj5) {
6476 ecode7 = SWIG_AsVal_int(obj5, &val7);
6477 if (!SWIG_IsOK(ecode7)) {
6478 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6479 }
6480 arg7 = static_cast< int >(val7);
6481 }
6482 if (obj6) {
6483 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6484 if (!SWIG_IsOK(ecode8)) {
6485 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6486 }
6487 arg8 = static_cast< bool >(val8);
6488 }
6489 if (obj7) {
6490 ecode9 = SWIG_AsVal_int(obj7, &val9);
6491 if (!SWIG_IsOK(ecode9)) {
6492 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6493 }
6494 arg9 = static_cast< int >(val9);
6495 }
6496 if (obj8) {
6497 ecode10 = SWIG_AsVal_int(obj8, &val10);
6498 if (!SWIG_IsOK(ecode10)) {
6499 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6500 }
6501 arg10 = static_cast< int >(val10);
6502 }
6503 {
6504 if (!wxPyCheckForApp()) SWIG_fail;
6505 PyThreadState* __tstate = wxPyBeginAllowThreads();
6506 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6507 wxPyEndAllowThreads(__tstate);
6508 if (PyErr_Occurred()) SWIG_fail;
6509 }
6510 resultobj = SWIG_From_int(static_cast< int >(result));
6511 {
6512 if (temp1)
6513 delete arg1;
6514 }
6515 {
6516 if (temp2)
6517 delete arg2;
6518 }
6519 {
6520 if (arg4) delete [] arg4;
6521 }
6522 return resultobj;
6523 fail:
6524 {
6525 if (temp1)
6526 delete arg1;
6527 }
6528 {
6529 if (temp2)
6530 delete arg2;
6531 }
6532 {
6533 if (arg4) delete [] arg4;
6534 }
6535 return NULL;
6536 }
6537
6538
6539 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6540 PyObject *resultobj = 0;
6541 wxString *arg1 = 0 ;
6542 wxString const &arg2_defvalue = wxPyEmptyString ;
6543 wxString *arg2 = (wxString *) &arg2_defvalue ;
6544 int arg3 = (int) wxOK|wxCENTRE ;
6545 wxWindow *arg4 = (wxWindow *) NULL ;
6546 int arg5 = (int) -1 ;
6547 int arg6 = (int) -1 ;
6548 int result;
6549 bool temp1 = false ;
6550 bool temp2 = false ;
6551 int val3 ;
6552 int ecode3 = 0 ;
6553 void *argp4 = 0 ;
6554 int res4 = 0 ;
6555 int val5 ;
6556 int ecode5 = 0 ;
6557 int val6 ;
6558 int ecode6 = 0 ;
6559 PyObject * obj0 = 0 ;
6560 PyObject * obj1 = 0 ;
6561 PyObject * obj2 = 0 ;
6562 PyObject * obj3 = 0 ;
6563 PyObject * obj4 = 0 ;
6564 PyObject * obj5 = 0 ;
6565 char * kwnames[] = {
6566 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6567 };
6568
6569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6570 {
6571 arg1 = wxString_in_helper(obj0);
6572 if (arg1 == NULL) SWIG_fail;
6573 temp1 = true;
6574 }
6575 if (obj1) {
6576 {
6577 arg2 = wxString_in_helper(obj1);
6578 if (arg2 == NULL) SWIG_fail;
6579 temp2 = true;
6580 }
6581 }
6582 if (obj2) {
6583 ecode3 = SWIG_AsVal_int(obj2, &val3);
6584 if (!SWIG_IsOK(ecode3)) {
6585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6586 }
6587 arg3 = static_cast< int >(val3);
6588 }
6589 if (obj3) {
6590 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6591 if (!SWIG_IsOK(res4)) {
6592 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6593 }
6594 arg4 = reinterpret_cast< wxWindow * >(argp4);
6595 }
6596 if (obj4) {
6597 ecode5 = SWIG_AsVal_int(obj4, &val5);
6598 if (!SWIG_IsOK(ecode5)) {
6599 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6600 }
6601 arg5 = static_cast< int >(val5);
6602 }
6603 if (obj5) {
6604 ecode6 = SWIG_AsVal_int(obj5, &val6);
6605 if (!SWIG_IsOK(ecode6)) {
6606 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6607 }
6608 arg6 = static_cast< int >(val6);
6609 }
6610 {
6611 if (!wxPyCheckForApp()) SWIG_fail;
6612 PyThreadState* __tstate = wxPyBeginAllowThreads();
6613 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6614 wxPyEndAllowThreads(__tstate);
6615 if (PyErr_Occurred()) SWIG_fail;
6616 }
6617 resultobj = SWIG_From_int(static_cast< int >(result));
6618 {
6619 if (temp1)
6620 delete arg1;
6621 }
6622 {
6623 if (temp2)
6624 delete arg2;
6625 }
6626 return resultobj;
6627 fail:
6628 {
6629 if (temp1)
6630 delete arg1;
6631 }
6632 {
6633 if (temp2)
6634 delete arg2;
6635 }
6636 return NULL;
6637 }
6638
6639
6640 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6641 PyObject *resultobj = 0;
6642 wxString *arg1 = 0 ;
6643 wxString *arg2 = 0 ;
6644 wxString *arg3 = 0 ;
6645 long arg4 ;
6646 long arg5 = (long) 0 ;
6647 long arg6 = (long) 100 ;
6648 wxWindow *arg7 = (wxWindow *) NULL ;
6649 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6650 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6651 long result;
6652 bool temp1 = false ;
6653 bool temp2 = false ;
6654 bool temp3 = false ;
6655 long val4 ;
6656 int ecode4 = 0 ;
6657 long val5 ;
6658 int ecode5 = 0 ;
6659 long val6 ;
6660 int ecode6 = 0 ;
6661 void *argp7 = 0 ;
6662 int res7 = 0 ;
6663 wxPoint temp8 ;
6664 PyObject * obj0 = 0 ;
6665 PyObject * obj1 = 0 ;
6666 PyObject * obj2 = 0 ;
6667 PyObject * obj3 = 0 ;
6668 PyObject * obj4 = 0 ;
6669 PyObject * obj5 = 0 ;
6670 PyObject * obj6 = 0 ;
6671 PyObject * obj7 = 0 ;
6672 char * kwnames[] = {
6673 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6674 };
6675
6676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6677 {
6678 arg1 = wxString_in_helper(obj0);
6679 if (arg1 == NULL) SWIG_fail;
6680 temp1 = true;
6681 }
6682 {
6683 arg2 = wxString_in_helper(obj1);
6684 if (arg2 == NULL) SWIG_fail;
6685 temp2 = true;
6686 }
6687 {
6688 arg3 = wxString_in_helper(obj2);
6689 if (arg3 == NULL) SWIG_fail;
6690 temp3 = true;
6691 }
6692 ecode4 = SWIG_AsVal_long(obj3, &val4);
6693 if (!SWIG_IsOK(ecode4)) {
6694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6695 }
6696 arg4 = static_cast< long >(val4);
6697 if (obj4) {
6698 ecode5 = SWIG_AsVal_long(obj4, &val5);
6699 if (!SWIG_IsOK(ecode5)) {
6700 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6701 }
6702 arg5 = static_cast< long >(val5);
6703 }
6704 if (obj5) {
6705 ecode6 = SWIG_AsVal_long(obj5, &val6);
6706 if (!SWIG_IsOK(ecode6)) {
6707 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6708 }
6709 arg6 = static_cast< long >(val6);
6710 }
6711 if (obj6) {
6712 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6713 if (!SWIG_IsOK(res7)) {
6714 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6715 }
6716 arg7 = reinterpret_cast< wxWindow * >(argp7);
6717 }
6718 if (obj7) {
6719 {
6720 arg8 = &temp8;
6721 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6722 }
6723 }
6724 {
6725 if (!wxPyCheckForApp()) SWIG_fail;
6726 PyThreadState* __tstate = wxPyBeginAllowThreads();
6727 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 resultobj = SWIG_From_long(static_cast< long >(result));
6732 {
6733 if (temp1)
6734 delete arg1;
6735 }
6736 {
6737 if (temp2)
6738 delete arg2;
6739 }
6740 {
6741 if (temp3)
6742 delete arg3;
6743 }
6744 return resultobj;
6745 fail:
6746 {
6747 if (temp1)
6748 delete arg1;
6749 }
6750 {
6751 if (temp2)
6752 delete arg2;
6753 }
6754 {
6755 if (temp3)
6756 delete arg3;
6757 }
6758 return NULL;
6759 }
6760
6761
6762 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6763 PyObject *resultobj = 0;
6764 bool result;
6765
6766 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6767 {
6768 if (!wxPyCheckForApp()) SWIG_fail;
6769 PyThreadState* __tstate = wxPyBeginAllowThreads();
6770 result = (bool)wxColourDisplay();
6771 wxPyEndAllowThreads(__tstate);
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 {
6775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6776 }
6777 return resultobj;
6778 fail:
6779 return NULL;
6780 }
6781
6782
6783 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6784 PyObject *resultobj = 0;
6785 int result;
6786
6787 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6788 {
6789 if (!wxPyCheckForApp()) SWIG_fail;
6790 PyThreadState* __tstate = wxPyBeginAllowThreads();
6791 result = (int)wxDisplayDepth();
6792 wxPyEndAllowThreads(__tstate);
6793 if (PyErr_Occurred()) SWIG_fail;
6794 }
6795 resultobj = SWIG_From_int(static_cast< int >(result));
6796 return resultobj;
6797 fail:
6798 return NULL;
6799 }
6800
6801
6802 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6803 PyObject *resultobj = 0;
6804 int result;
6805
6806 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6807 {
6808 if (!wxPyCheckForApp()) SWIG_fail;
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 result = (int)wxGetDisplayDepth();
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 resultobj = SWIG_From_int(static_cast< int >(result));
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6822 PyObject *resultobj = 0;
6823 int *arg1 = (int *) 0 ;
6824 int *arg2 = (int *) 0 ;
6825 int temp1 ;
6826 int res1 = SWIG_TMPOBJ ;
6827 int temp2 ;
6828 int res2 = SWIG_TMPOBJ ;
6829
6830 arg1 = &temp1;
6831 arg2 = &temp2;
6832 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6833 {
6834 if (!wxPyCheckForApp()) SWIG_fail;
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 wxDisplaySize(arg1,arg2);
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 resultobj = SWIG_Py_Void();
6841 if (SWIG_IsTmpObj(res1)) {
6842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6843 } else {
6844 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6846 }
6847 if (SWIG_IsTmpObj(res2)) {
6848 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6849 } else {
6850 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6851 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6852 }
6853 return resultobj;
6854 fail:
6855 return NULL;
6856 }
6857
6858
6859 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6860 PyObject *resultobj = 0;
6861 wxSize result;
6862
6863 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6864 {
6865 if (!wxPyCheckForApp()) SWIG_fail;
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 result = wxGetDisplaySize();
6868 wxPyEndAllowThreads(__tstate);
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6872 return resultobj;
6873 fail:
6874 return NULL;
6875 }
6876
6877
6878 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6879 PyObject *resultobj = 0;
6880 int *arg1 = (int *) 0 ;
6881 int *arg2 = (int *) 0 ;
6882 int temp1 ;
6883 int res1 = SWIG_TMPOBJ ;
6884 int temp2 ;
6885 int res2 = SWIG_TMPOBJ ;
6886
6887 arg1 = &temp1;
6888 arg2 = &temp2;
6889 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6890 {
6891 if (!wxPyCheckForApp()) SWIG_fail;
6892 PyThreadState* __tstate = wxPyBeginAllowThreads();
6893 wxDisplaySizeMM(arg1,arg2);
6894 wxPyEndAllowThreads(__tstate);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 resultobj = SWIG_Py_Void();
6898 if (SWIG_IsTmpObj(res1)) {
6899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6900 } else {
6901 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6903 }
6904 if (SWIG_IsTmpObj(res2)) {
6905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6906 } else {
6907 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6909 }
6910 return resultobj;
6911 fail:
6912 return NULL;
6913 }
6914
6915
6916 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6917 PyObject *resultobj = 0;
6918 wxSize result;
6919
6920 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6921 {
6922 if (!wxPyCheckForApp()) SWIG_fail;
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 result = wxGetDisplaySizeMM();
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6936 PyObject *resultobj = 0;
6937 int *arg1 = (int *) 0 ;
6938 int *arg2 = (int *) 0 ;
6939 int *arg3 = (int *) 0 ;
6940 int *arg4 = (int *) 0 ;
6941 int temp1 ;
6942 int res1 = SWIG_TMPOBJ ;
6943 int temp2 ;
6944 int res2 = SWIG_TMPOBJ ;
6945 int temp3 ;
6946 int res3 = SWIG_TMPOBJ ;
6947 int temp4 ;
6948 int res4 = SWIG_TMPOBJ ;
6949
6950 arg1 = &temp1;
6951 arg2 = &temp2;
6952 arg3 = &temp3;
6953 arg4 = &temp4;
6954 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6955 {
6956 if (!wxPyCheckForApp()) SWIG_fail;
6957 PyThreadState* __tstate = wxPyBeginAllowThreads();
6958 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6959 wxPyEndAllowThreads(__tstate);
6960 if (PyErr_Occurred()) SWIG_fail;
6961 }
6962 resultobj = SWIG_Py_Void();
6963 if (SWIG_IsTmpObj(res1)) {
6964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6965 } else {
6966 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6968 }
6969 if (SWIG_IsTmpObj(res2)) {
6970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6971 } else {
6972 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6974 }
6975 if (SWIG_IsTmpObj(res3)) {
6976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6977 } else {
6978 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6980 }
6981 if (SWIG_IsTmpObj(res4)) {
6982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6983 } else {
6984 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6986 }
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6994 PyObject *resultobj = 0;
6995 wxRect result;
6996
6997 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6998 {
6999 if (!wxPyCheckForApp()) SWIG_fail;
7000 PyThreadState* __tstate = wxPyBeginAllowThreads();
7001 result = wxGetClientDisplayRect();
7002 wxPyEndAllowThreads(__tstate);
7003 if (PyErr_Occurred()) SWIG_fail;
7004 }
7005 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7006 return resultobj;
7007 fail:
7008 return NULL;
7009 }
7010
7011
7012 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7013 PyObject *resultobj = 0;
7014 wxCursor *arg1 = 0 ;
7015 void *argp1 = 0 ;
7016 int res1 = 0 ;
7017 PyObject * obj0 = 0 ;
7018 char * kwnames[] = {
7019 (char *) "cursor", NULL
7020 };
7021
7022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7023 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7024 if (!SWIG_IsOK(res1)) {
7025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7026 }
7027 if (!argp1) {
7028 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7029 }
7030 arg1 = reinterpret_cast< wxCursor * >(argp1);
7031 {
7032 if (!wxPyCheckForApp()) SWIG_fail;
7033 PyThreadState* __tstate = wxPyBeginAllowThreads();
7034 wxSetCursor(*arg1);
7035 wxPyEndAllowThreads(__tstate);
7036 if (PyErr_Occurred()) SWIG_fail;
7037 }
7038 resultobj = SWIG_Py_Void();
7039 return resultobj;
7040 fail:
7041 return NULL;
7042 }
7043
7044
7045 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7046 PyObject *resultobj = 0;
7047 void *result = 0 ;
7048
7049 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7050 {
7051 if (!wxPyCheckForApp()) SWIG_fail;
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 result = (void *)wxGetXDisplay();
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7067 void *argp1 = 0 ;
7068 int res1 = 0 ;
7069 PyObject * obj0 = 0 ;
7070 char * kwnames[] = {
7071 (char *) "cursor", NULL
7072 };
7073
7074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7075 if (obj0) {
7076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7077 if (!SWIG_IsOK(res1)) {
7078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7079 }
7080 arg1 = reinterpret_cast< wxCursor * >(argp1);
7081 }
7082 {
7083 if (!wxPyCheckForApp()) SWIG_fail;
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 wxBeginBusyCursor(arg1);
7086 wxPyEndAllowThreads(__tstate);
7087 if (PyErr_Occurred()) SWIG_fail;
7088 }
7089 resultobj = SWIG_Py_Void();
7090 return resultobj;
7091 fail:
7092 return NULL;
7093 }
7094
7095
7096 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7097 PyObject *resultobj = 0;
7098 wxPoint result;
7099
7100 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7101 {
7102 if (!wxPyCheckForApp()) SWIG_fail;
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = wxGetMousePosition();
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7109 return resultobj;
7110 fail:
7111 return NULL;
7112 }
7113
7114
7115 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7116 PyObject *resultobj = 0;
7117 wxWindow *result = 0 ;
7118
7119 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7120 {
7121 if (!wxPyCheckForApp()) SWIG_fail;
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 result = (wxWindow *)FindWindowAtPointer();
7124 wxPyEndAllowThreads(__tstate);
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 {
7128 resultobj = wxPyMake_wxObject(result, 0);
7129 }
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137 PyObject *resultobj = 0;
7138 wxWindow *result = 0 ;
7139
7140 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7141 {
7142 if (!wxPyCheckForApp()) SWIG_fail;
7143 PyThreadState* __tstate = wxPyBeginAllowThreads();
7144 result = (wxWindow *)wxGetActiveWindow();
7145 wxPyEndAllowThreads(__tstate);
7146 if (PyErr_Occurred()) SWIG_fail;
7147 }
7148 {
7149 resultobj = wxPyMake_wxObject(result, 0);
7150 }
7151 return resultobj;
7152 fail:
7153 return NULL;
7154 }
7155
7156
7157 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7158 PyObject *resultobj = 0;
7159 wxPoint *arg1 = 0 ;
7160 wxWindow *result = 0 ;
7161 wxPoint temp1 ;
7162 PyObject * obj0 = 0 ;
7163 char * kwnames[] = {
7164 (char *) "pt", NULL
7165 };
7166
7167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7168 {
7169 arg1 = &temp1;
7170 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7171 }
7172 {
7173 if (!wxPyCheckForApp()) SWIG_fail;
7174 PyThreadState* __tstate = wxPyBeginAllowThreads();
7175 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7176 wxPyEndAllowThreads(__tstate);
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 {
7180 resultobj = wxPyMake_wxObject(result, 0);
7181 }
7182 return resultobj;
7183 fail:
7184 return NULL;
7185 }
7186
7187
7188 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7189 PyObject *resultobj = 0;
7190 wxPoint *arg1 = 0 ;
7191 wxWindow *result = 0 ;
7192 wxPoint temp1 ;
7193 PyObject * obj0 = 0 ;
7194 char * kwnames[] = {
7195 (char *) "pt", NULL
7196 };
7197
7198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7199 {
7200 arg1 = &temp1;
7201 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7202 }
7203 {
7204 if (!wxPyCheckForApp()) SWIG_fail;
7205 PyThreadState* __tstate = wxPyBeginAllowThreads();
7206 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 {
7211 resultobj = wxPyMake_wxObject(result, 0);
7212 }
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj = 0;
7221 wxWindow *arg1 = (wxWindow *) 0 ;
7222 wxWindow *result = 0 ;
7223 void *argp1 = 0 ;
7224 int res1 = 0 ;
7225 PyObject * obj0 = 0 ;
7226 char * kwnames[] = {
7227 (char *) "win", NULL
7228 };
7229
7230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7232 if (!SWIG_IsOK(res1)) {
7233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7234 }
7235 arg1 = reinterpret_cast< wxWindow * >(argp1);
7236 {
7237 if (!wxPyCheckForApp()) SWIG_fail;
7238 PyThreadState* __tstate = wxPyBeginAllowThreads();
7239 result = (wxWindow *)wxGetTopLevelParent(arg1);
7240 wxPyEndAllowThreads(__tstate);
7241 if (PyErr_Occurred()) SWIG_fail;
7242 }
7243 {
7244 resultobj = wxPyMake_wxObject(result, 0);
7245 }
7246 return resultobj;
7247 fail:
7248 return NULL;
7249 }
7250
7251
7252 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7253 PyObject *resultobj = 0;
7254 wxString *arg1 = 0 ;
7255 bool result;
7256 bool temp1 = false ;
7257 PyObject * obj0 = 0 ;
7258 char * kwnames[] = {
7259 (char *) "url", NULL
7260 };
7261
7262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7263 {
7264 arg1 = wxString_in_helper(obj0);
7265 if (arg1 == NULL) SWIG_fail;
7266 temp1 = true;
7267 }
7268 {
7269 PyThreadState* __tstate = wxPyBeginAllowThreads();
7270 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7271 wxPyEndAllowThreads(__tstate);
7272 if (PyErr_Occurred()) SWIG_fail;
7273 }
7274 {
7275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7276 }
7277 {
7278 if (temp1)
7279 delete arg1;
7280 }
7281 return resultobj;
7282 fail:
7283 {
7284 if (temp1)
7285 delete arg1;
7286 }
7287 return NULL;
7288 }
7289
7290
7291 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7292 PyObject *resultobj = 0;
7293 wxKeyCode arg1 ;
7294 bool result;
7295 int val1 ;
7296 int ecode1 = 0 ;
7297 PyObject * obj0 = 0 ;
7298 char * kwnames[] = {
7299 (char *) "key", NULL
7300 };
7301
7302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7303 ecode1 = SWIG_AsVal_int(obj0, &val1);
7304 if (!SWIG_IsOK(ecode1)) {
7305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7306 }
7307 arg1 = static_cast< wxKeyCode >(val1);
7308 {
7309 if (!wxPyCheckForApp()) SWIG_fail;
7310 PyThreadState* __tstate = wxPyBeginAllowThreads();
7311 result = (bool)wxGetKeyState(arg1);
7312 wxPyEndAllowThreads(__tstate);
7313 if (PyErr_Occurred()) SWIG_fail;
7314 }
7315 {
7316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7317 }
7318 return resultobj;
7319 fail:
7320 return NULL;
7321 }
7322
7323
7324 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7325 PyObject *resultobj = 0;
7326 wxMouseState *result = 0 ;
7327
7328 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7329 {
7330 PyThreadState* __tstate = wxPyBeginAllowThreads();
7331 result = (wxMouseState *)new wxMouseState();
7332 wxPyEndAllowThreads(__tstate);
7333 if (PyErr_Occurred()) SWIG_fail;
7334 }
7335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7336 return resultobj;
7337 fail:
7338 return NULL;
7339 }
7340
7341
7342 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7343 PyObject *resultobj = 0;
7344 wxMouseState *arg1 = (wxMouseState *) 0 ;
7345 void *argp1 = 0 ;
7346 int res1 = 0 ;
7347 PyObject *swig_obj[1] ;
7348
7349 if (!args) SWIG_fail;
7350 swig_obj[0] = args;
7351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7352 if (!SWIG_IsOK(res1)) {
7353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7354 }
7355 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7356 {
7357 PyThreadState* __tstate = wxPyBeginAllowThreads();
7358 delete arg1;
7359
7360 wxPyEndAllowThreads(__tstate);
7361 if (PyErr_Occurred()) SWIG_fail;
7362 }
7363 resultobj = SWIG_Py_Void();
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7371 PyObject *resultobj = 0;
7372 wxMouseState *arg1 = (wxMouseState *) 0 ;
7373 int result;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 PyObject *swig_obj[1] ;
7377
7378 if (!args) SWIG_fail;
7379 swig_obj[0] = args;
7380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7381 if (!SWIG_IsOK(res1)) {
7382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7383 }
7384 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7385 {
7386 PyThreadState* __tstate = wxPyBeginAllowThreads();
7387 result = (int)(arg1)->GetX();
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 resultobj = SWIG_From_int(static_cast< int >(result));
7392 return resultobj;
7393 fail:
7394 return NULL;
7395 }
7396
7397
7398 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7399 PyObject *resultobj = 0;
7400 wxMouseState *arg1 = (wxMouseState *) 0 ;
7401 int result;
7402 void *argp1 = 0 ;
7403 int res1 = 0 ;
7404 PyObject *swig_obj[1] ;
7405
7406 if (!args) SWIG_fail;
7407 swig_obj[0] = args;
7408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7409 if (!SWIG_IsOK(res1)) {
7410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7411 }
7412 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 result = (int)(arg1)->GetY();
7416 wxPyEndAllowThreads(__tstate);
7417 if (PyErr_Occurred()) SWIG_fail;
7418 }
7419 resultobj = SWIG_From_int(static_cast< int >(result));
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7427 PyObject *resultobj = 0;
7428 wxMouseState *arg1 = (wxMouseState *) 0 ;
7429 bool result;
7430 void *argp1 = 0 ;
7431 int res1 = 0 ;
7432 PyObject *swig_obj[1] ;
7433
7434 if (!args) SWIG_fail;
7435 swig_obj[0] = args;
7436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7437 if (!SWIG_IsOK(res1)) {
7438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7439 }
7440 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7441 {
7442 PyThreadState* __tstate = wxPyBeginAllowThreads();
7443 result = (bool)(arg1)->LeftDown();
7444 wxPyEndAllowThreads(__tstate);
7445 if (PyErr_Occurred()) SWIG_fail;
7446 }
7447 {
7448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7449 }
7450 return resultobj;
7451 fail:
7452 return NULL;
7453 }
7454
7455
7456 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7457 PyObject *resultobj = 0;
7458 wxMouseState *arg1 = (wxMouseState *) 0 ;
7459 bool result;
7460 void *argp1 = 0 ;
7461 int res1 = 0 ;
7462 PyObject *swig_obj[1] ;
7463
7464 if (!args) SWIG_fail;
7465 swig_obj[0] = args;
7466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7467 if (!SWIG_IsOK(res1)) {
7468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7469 }
7470 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7471 {
7472 PyThreadState* __tstate = wxPyBeginAllowThreads();
7473 result = (bool)(arg1)->MiddleDown();
7474 wxPyEndAllowThreads(__tstate);
7475 if (PyErr_Occurred()) SWIG_fail;
7476 }
7477 {
7478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7479 }
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7487 PyObject *resultobj = 0;
7488 wxMouseState *arg1 = (wxMouseState *) 0 ;
7489 bool result;
7490 void *argp1 = 0 ;
7491 int res1 = 0 ;
7492 PyObject *swig_obj[1] ;
7493
7494 if (!args) SWIG_fail;
7495 swig_obj[0] = args;
7496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7497 if (!SWIG_IsOK(res1)) {
7498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7499 }
7500 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7501 {
7502 PyThreadState* __tstate = wxPyBeginAllowThreads();
7503 result = (bool)(arg1)->RightDown();
7504 wxPyEndAllowThreads(__tstate);
7505 if (PyErr_Occurred()) SWIG_fail;
7506 }
7507 {
7508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7509 }
7510 return resultobj;
7511 fail:
7512 return NULL;
7513 }
7514
7515
7516 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7517 PyObject *resultobj = 0;
7518 wxMouseState *arg1 = (wxMouseState *) 0 ;
7519 bool result;
7520 void *argp1 = 0 ;
7521 int res1 = 0 ;
7522 PyObject *swig_obj[1] ;
7523
7524 if (!args) SWIG_fail;
7525 swig_obj[0] = args;
7526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7527 if (!SWIG_IsOK(res1)) {
7528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7529 }
7530 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7531 {
7532 PyThreadState* __tstate = wxPyBeginAllowThreads();
7533 result = (bool)(arg1)->ControlDown();
7534 wxPyEndAllowThreads(__tstate);
7535 if (PyErr_Occurred()) SWIG_fail;
7536 }
7537 {
7538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7539 }
7540 return resultobj;
7541 fail:
7542 return NULL;
7543 }
7544
7545
7546 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7547 PyObject *resultobj = 0;
7548 wxMouseState *arg1 = (wxMouseState *) 0 ;
7549 bool result;
7550 void *argp1 = 0 ;
7551 int res1 = 0 ;
7552 PyObject *swig_obj[1] ;
7553
7554 if (!args) SWIG_fail;
7555 swig_obj[0] = args;
7556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7557 if (!SWIG_IsOK(res1)) {
7558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7559 }
7560 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (bool)(arg1)->ShiftDown();
7564 wxPyEndAllowThreads(__tstate);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 {
7568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7569 }
7570 return resultobj;
7571 fail:
7572 return NULL;
7573 }
7574
7575
7576 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7577 PyObject *resultobj = 0;
7578 wxMouseState *arg1 = (wxMouseState *) 0 ;
7579 bool result;
7580 void *argp1 = 0 ;
7581 int res1 = 0 ;
7582 PyObject *swig_obj[1] ;
7583
7584 if (!args) SWIG_fail;
7585 swig_obj[0] = args;
7586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7587 if (!SWIG_IsOK(res1)) {
7588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7589 }
7590 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (bool)(arg1)->AltDown();
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 {
7598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7599 }
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7607 PyObject *resultobj = 0;
7608 wxMouseState *arg1 = (wxMouseState *) 0 ;
7609 bool result;
7610 void *argp1 = 0 ;
7611 int res1 = 0 ;
7612 PyObject *swig_obj[1] ;
7613
7614 if (!args) SWIG_fail;
7615 swig_obj[0] = args;
7616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7617 if (!SWIG_IsOK(res1)) {
7618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7619 }
7620 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7621 {
7622 PyThreadState* __tstate = wxPyBeginAllowThreads();
7623 result = (bool)(arg1)->MetaDown();
7624 wxPyEndAllowThreads(__tstate);
7625 if (PyErr_Occurred()) SWIG_fail;
7626 }
7627 {
7628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7629 }
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7637 PyObject *resultobj = 0;
7638 wxMouseState *arg1 = (wxMouseState *) 0 ;
7639 bool result;
7640 void *argp1 = 0 ;
7641 int res1 = 0 ;
7642 PyObject *swig_obj[1] ;
7643
7644 if (!args) SWIG_fail;
7645 swig_obj[0] = args;
7646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7647 if (!SWIG_IsOK(res1)) {
7648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7649 }
7650 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7651 {
7652 PyThreadState* __tstate = wxPyBeginAllowThreads();
7653 result = (bool)(arg1)->CmdDown();
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 {
7658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7659 }
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7667 PyObject *resultobj = 0;
7668 wxMouseState *arg1 = (wxMouseState *) 0 ;
7669 int arg2 ;
7670 void *argp1 = 0 ;
7671 int res1 = 0 ;
7672 int val2 ;
7673 int ecode2 = 0 ;
7674 PyObject * obj0 = 0 ;
7675 PyObject * obj1 = 0 ;
7676 char * kwnames[] = {
7677 (char *) "self",(char *) "x", NULL
7678 };
7679
7680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7682 if (!SWIG_IsOK(res1)) {
7683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7684 }
7685 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7686 ecode2 = SWIG_AsVal_int(obj1, &val2);
7687 if (!SWIG_IsOK(ecode2)) {
7688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7689 }
7690 arg2 = static_cast< int >(val2);
7691 {
7692 PyThreadState* __tstate = wxPyBeginAllowThreads();
7693 (arg1)->SetX(arg2);
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 resultobj = SWIG_Py_Void();
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj = 0;
7706 wxMouseState *arg1 = (wxMouseState *) 0 ;
7707 int arg2 ;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 PyObject * obj0 = 0 ;
7713 PyObject * obj1 = 0 ;
7714 char * kwnames[] = {
7715 (char *) "self",(char *) "y", NULL
7716 };
7717
7718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7720 if (!SWIG_IsOK(res1)) {
7721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7722 }
7723 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7724 ecode2 = SWIG_AsVal_int(obj1, &val2);
7725 if (!SWIG_IsOK(ecode2)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7727 }
7728 arg2 = static_cast< int >(val2);
7729 {
7730 PyThreadState* __tstate = wxPyBeginAllowThreads();
7731 (arg1)->SetY(arg2);
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 resultobj = SWIG_Py_Void();
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj = 0;
7744 wxMouseState *arg1 = (wxMouseState *) 0 ;
7745 bool arg2 ;
7746 void *argp1 = 0 ;
7747 int res1 = 0 ;
7748 bool val2 ;
7749 int ecode2 = 0 ;
7750 PyObject * obj0 = 0 ;
7751 PyObject * obj1 = 0 ;
7752 char * kwnames[] = {
7753 (char *) "self",(char *) "down", NULL
7754 };
7755
7756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7760 }
7761 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7763 if (!SWIG_IsOK(ecode2)) {
7764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7765 }
7766 arg2 = static_cast< bool >(val2);
7767 {
7768 PyThreadState* __tstate = wxPyBeginAllowThreads();
7769 (arg1)->SetLeftDown(arg2);
7770 wxPyEndAllowThreads(__tstate);
7771 if (PyErr_Occurred()) SWIG_fail;
7772 }
7773 resultobj = SWIG_Py_Void();
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj = 0;
7782 wxMouseState *arg1 = (wxMouseState *) 0 ;
7783 bool arg2 ;
7784 void *argp1 = 0 ;
7785 int res1 = 0 ;
7786 bool val2 ;
7787 int ecode2 = 0 ;
7788 PyObject * obj0 = 0 ;
7789 PyObject * obj1 = 0 ;
7790 char * kwnames[] = {
7791 (char *) "self",(char *) "down", NULL
7792 };
7793
7794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7796 if (!SWIG_IsOK(res1)) {
7797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7798 }
7799 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7800 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7801 if (!SWIG_IsOK(ecode2)) {
7802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7803 }
7804 arg2 = static_cast< bool >(val2);
7805 {
7806 PyThreadState* __tstate = wxPyBeginAllowThreads();
7807 (arg1)->SetMiddleDown(arg2);
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 resultobj = SWIG_Py_Void();
7812 return resultobj;
7813 fail:
7814 return NULL;
7815 }
7816
7817
7818 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7819 PyObject *resultobj = 0;
7820 wxMouseState *arg1 = (wxMouseState *) 0 ;
7821 bool arg2 ;
7822 void *argp1 = 0 ;
7823 int res1 = 0 ;
7824 bool val2 ;
7825 int ecode2 = 0 ;
7826 PyObject * obj0 = 0 ;
7827 PyObject * obj1 = 0 ;
7828 char * kwnames[] = {
7829 (char *) "self",(char *) "down", NULL
7830 };
7831
7832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7834 if (!SWIG_IsOK(res1)) {
7835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7836 }
7837 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7839 if (!SWIG_IsOK(ecode2)) {
7840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7841 }
7842 arg2 = static_cast< bool >(val2);
7843 {
7844 PyThreadState* __tstate = wxPyBeginAllowThreads();
7845 (arg1)->SetRightDown(arg2);
7846 wxPyEndAllowThreads(__tstate);
7847 if (PyErr_Occurred()) SWIG_fail;
7848 }
7849 resultobj = SWIG_Py_Void();
7850 return resultobj;
7851 fail:
7852 return NULL;
7853 }
7854
7855
7856 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7857 PyObject *resultobj = 0;
7858 wxMouseState *arg1 = (wxMouseState *) 0 ;
7859 bool arg2 ;
7860 void *argp1 = 0 ;
7861 int res1 = 0 ;
7862 bool val2 ;
7863 int ecode2 = 0 ;
7864 PyObject * obj0 = 0 ;
7865 PyObject * obj1 = 0 ;
7866 char * kwnames[] = {
7867 (char *) "self",(char *) "down", NULL
7868 };
7869
7870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7872 if (!SWIG_IsOK(res1)) {
7873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7874 }
7875 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7876 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7877 if (!SWIG_IsOK(ecode2)) {
7878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7879 }
7880 arg2 = static_cast< bool >(val2);
7881 {
7882 PyThreadState* __tstate = wxPyBeginAllowThreads();
7883 (arg1)->SetControlDown(arg2);
7884 wxPyEndAllowThreads(__tstate);
7885 if (PyErr_Occurred()) SWIG_fail;
7886 }
7887 resultobj = SWIG_Py_Void();
7888 return resultobj;
7889 fail:
7890 return NULL;
7891 }
7892
7893
7894 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7895 PyObject *resultobj = 0;
7896 wxMouseState *arg1 = (wxMouseState *) 0 ;
7897 bool arg2 ;
7898 void *argp1 = 0 ;
7899 int res1 = 0 ;
7900 bool val2 ;
7901 int ecode2 = 0 ;
7902 PyObject * obj0 = 0 ;
7903 PyObject * obj1 = 0 ;
7904 char * kwnames[] = {
7905 (char *) "self",(char *) "down", NULL
7906 };
7907
7908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7910 if (!SWIG_IsOK(res1)) {
7911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7912 }
7913 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7914 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7915 if (!SWIG_IsOK(ecode2)) {
7916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7917 }
7918 arg2 = static_cast< bool >(val2);
7919 {
7920 PyThreadState* __tstate = wxPyBeginAllowThreads();
7921 (arg1)->SetShiftDown(arg2);
7922 wxPyEndAllowThreads(__tstate);
7923 if (PyErr_Occurred()) SWIG_fail;
7924 }
7925 resultobj = SWIG_Py_Void();
7926 return resultobj;
7927 fail:
7928 return NULL;
7929 }
7930
7931
7932 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7933 PyObject *resultobj = 0;
7934 wxMouseState *arg1 = (wxMouseState *) 0 ;
7935 bool arg2 ;
7936 void *argp1 = 0 ;
7937 int res1 = 0 ;
7938 bool val2 ;
7939 int ecode2 = 0 ;
7940 PyObject * obj0 = 0 ;
7941 PyObject * obj1 = 0 ;
7942 char * kwnames[] = {
7943 (char *) "self",(char *) "down", NULL
7944 };
7945
7946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7948 if (!SWIG_IsOK(res1)) {
7949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7950 }
7951 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7952 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7953 if (!SWIG_IsOK(ecode2)) {
7954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7955 }
7956 arg2 = static_cast< bool >(val2);
7957 {
7958 PyThreadState* __tstate = wxPyBeginAllowThreads();
7959 (arg1)->SetAltDown(arg2);
7960 wxPyEndAllowThreads(__tstate);
7961 if (PyErr_Occurred()) SWIG_fail;
7962 }
7963 resultobj = SWIG_Py_Void();
7964 return resultobj;
7965 fail:
7966 return NULL;
7967 }
7968
7969
7970 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7971 PyObject *resultobj = 0;
7972 wxMouseState *arg1 = (wxMouseState *) 0 ;
7973 bool arg2 ;
7974 void *argp1 = 0 ;
7975 int res1 = 0 ;
7976 bool val2 ;
7977 int ecode2 = 0 ;
7978 PyObject * obj0 = 0 ;
7979 PyObject * obj1 = 0 ;
7980 char * kwnames[] = {
7981 (char *) "self",(char *) "down", NULL
7982 };
7983
7984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7986 if (!SWIG_IsOK(res1)) {
7987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7988 }
7989 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7991 if (!SWIG_IsOK(ecode2)) {
7992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7993 }
7994 arg2 = static_cast< bool >(val2);
7995 {
7996 PyThreadState* __tstate = wxPyBeginAllowThreads();
7997 (arg1)->SetMetaDown(arg2);
7998 wxPyEndAllowThreads(__tstate);
7999 if (PyErr_Occurred()) SWIG_fail;
8000 }
8001 resultobj = SWIG_Py_Void();
8002 return resultobj;
8003 fail:
8004 return NULL;
8005 }
8006
8007
8008 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8009 PyObject *obj;
8010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8011 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8012 return SWIG_Py_Void();
8013 }
8014
8015 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8016 return SWIG_Python_InitShadowInstance(args);
8017 }
8018
8019 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8020 PyObject *resultobj = 0;
8021 wxMouseState result;
8022
8023 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = wxGetMouseState();
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8038 PyObject *resultobj = 0;
8039
8040 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8041 {
8042 if (!wxPyCheckForApp()) SWIG_fail;
8043 PyThreadState* __tstate = wxPyBeginAllowThreads();
8044 wxWakeUpMainThread();
8045 wxPyEndAllowThreads(__tstate);
8046 if (PyErr_Occurred()) SWIG_fail;
8047 }
8048 resultobj = SWIG_Py_Void();
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8056 PyObject *resultobj = 0;
8057
8058 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8059 {
8060 if (!wxPyCheckForApp()) SWIG_fail;
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 wxMutexGuiEnter();
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 resultobj = SWIG_Py_Void();
8067 return resultobj;
8068 fail:
8069 return NULL;
8070 }
8071
8072
8073 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8074 PyObject *resultobj = 0;
8075
8076 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8077 {
8078 if (!wxPyCheckForApp()) SWIG_fail;
8079 PyThreadState* __tstate = wxPyBeginAllowThreads();
8080 wxMutexGuiLeave();
8081 wxPyEndAllowThreads(__tstate);
8082 if (PyErr_Occurred()) SWIG_fail;
8083 }
8084 resultobj = SWIG_Py_Void();
8085 return resultobj;
8086 fail:
8087 return NULL;
8088 }
8089
8090
8091 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8092 PyObject *resultobj = 0;
8093 wxMutexGuiLocker *result = 0 ;
8094
8095 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8096 {
8097 if (!wxPyCheckForApp()) SWIG_fail;
8098 PyThreadState* __tstate = wxPyBeginAllowThreads();
8099 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8100 wxPyEndAllowThreads(__tstate);
8101 if (PyErr_Occurred()) SWIG_fail;
8102 }
8103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8104 return resultobj;
8105 fail:
8106 return NULL;
8107 }
8108
8109
8110 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8111 PyObject *resultobj = 0;
8112 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8113 void *argp1 = 0 ;
8114 int res1 = 0 ;
8115 PyObject *swig_obj[1] ;
8116
8117 if (!args) SWIG_fail;
8118 swig_obj[0] = args;
8119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8120 if (!SWIG_IsOK(res1)) {
8121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8122 }
8123 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 delete arg1;
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 resultobj = SWIG_Py_Void();
8132 return resultobj;
8133 fail:
8134 return NULL;
8135 }
8136
8137
8138 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8139 PyObject *obj;
8140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8141 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8142 return SWIG_Py_Void();
8143 }
8144
8145 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 return SWIG_Python_InitShadowInstance(args);
8147 }
8148
8149 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8150 PyObject *resultobj = 0;
8151 bool result;
8152
8153 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8154 {
8155 PyThreadState* __tstate = wxPyBeginAllowThreads();
8156 result = (bool)wxThread_IsMain();
8157 wxPyEndAllowThreads(__tstate);
8158 if (PyErr_Occurred()) SWIG_fail;
8159 }
8160 {
8161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8162 }
8163 return resultobj;
8164 fail:
8165 return NULL;
8166 }
8167
8168
8169 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8170 PyObject *resultobj = 0;
8171 wxString *arg1 = 0 ;
8172 wxToolTip *result = 0 ;
8173 bool temp1 = false ;
8174 PyObject * obj0 = 0 ;
8175 char * kwnames[] = {
8176 (char *) "tip", NULL
8177 };
8178
8179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8180 {
8181 arg1 = wxString_in_helper(obj0);
8182 if (arg1 == NULL) SWIG_fail;
8183 temp1 = true;
8184 }
8185 {
8186 if (!wxPyCheckForApp()) SWIG_fail;
8187 PyThreadState* __tstate = wxPyBeginAllowThreads();
8188 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8189 wxPyEndAllowThreads(__tstate);
8190 if (PyErr_Occurred()) SWIG_fail;
8191 }
8192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8193 {
8194 if (temp1)
8195 delete arg1;
8196 }
8197 return resultobj;
8198 fail:
8199 {
8200 if (temp1)
8201 delete arg1;
8202 }
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8208 PyObject *resultobj = 0;
8209 wxToolTip *arg1 = (wxToolTip *) 0 ;
8210 void *argp1 = 0 ;
8211 int res1 = 0 ;
8212 PyObject *swig_obj[1] ;
8213
8214 if (!args) SWIG_fail;
8215 swig_obj[0] = args;
8216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8217 if (!SWIG_IsOK(res1)) {
8218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8219 }
8220 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8221 {
8222 PyThreadState* __tstate = wxPyBeginAllowThreads();
8223 delete arg1;
8224
8225 wxPyEndAllowThreads(__tstate);
8226 if (PyErr_Occurred()) SWIG_fail;
8227 }
8228 resultobj = SWIG_Py_Void();
8229 return resultobj;
8230 fail:
8231 return NULL;
8232 }
8233
8234
8235 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8236 PyObject *resultobj = 0;
8237 wxToolTip *arg1 = (wxToolTip *) 0 ;
8238 wxString *arg2 = 0 ;
8239 void *argp1 = 0 ;
8240 int res1 = 0 ;
8241 bool temp2 = false ;
8242 PyObject * obj0 = 0 ;
8243 PyObject * obj1 = 0 ;
8244 char * kwnames[] = {
8245 (char *) "self",(char *) "tip", NULL
8246 };
8247
8248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8250 if (!SWIG_IsOK(res1)) {
8251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8252 }
8253 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8254 {
8255 arg2 = wxString_in_helper(obj1);
8256 if (arg2 == NULL) SWIG_fail;
8257 temp2 = true;
8258 }
8259 {
8260 PyThreadState* __tstate = wxPyBeginAllowThreads();
8261 (arg1)->SetTip((wxString const &)*arg2);
8262 wxPyEndAllowThreads(__tstate);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 resultobj = SWIG_Py_Void();
8266 {
8267 if (temp2)
8268 delete arg2;
8269 }
8270 return resultobj;
8271 fail:
8272 {
8273 if (temp2)
8274 delete arg2;
8275 }
8276 return NULL;
8277 }
8278
8279
8280 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8281 PyObject *resultobj = 0;
8282 wxToolTip *arg1 = (wxToolTip *) 0 ;
8283 wxString result;
8284 void *argp1 = 0 ;
8285 int res1 = 0 ;
8286 PyObject *swig_obj[1] ;
8287
8288 if (!args) SWIG_fail;
8289 swig_obj[0] = args;
8290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8291 if (!SWIG_IsOK(res1)) {
8292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8293 }
8294 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 result = (arg1)->GetTip();
8298 wxPyEndAllowThreads(__tstate);
8299 if (PyErr_Occurred()) SWIG_fail;
8300 }
8301 {
8302 #if wxUSE_UNICODE
8303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8304 #else
8305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8306 #endif
8307 }
8308 return resultobj;
8309 fail:
8310 return NULL;
8311 }
8312
8313
8314 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8315 PyObject *resultobj = 0;
8316 wxToolTip *arg1 = (wxToolTip *) 0 ;
8317 wxWindow *result = 0 ;
8318 void *argp1 = 0 ;
8319 int res1 = 0 ;
8320 PyObject *swig_obj[1] ;
8321
8322 if (!args) SWIG_fail;
8323 swig_obj[0] = args;
8324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8325 if (!SWIG_IsOK(res1)) {
8326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8327 }
8328 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8329 {
8330 PyThreadState* __tstate = wxPyBeginAllowThreads();
8331 result = (wxWindow *)(arg1)->GetWindow();
8332 wxPyEndAllowThreads(__tstate);
8333 if (PyErr_Occurred()) SWIG_fail;
8334 }
8335 {
8336 resultobj = wxPyMake_wxObject(result, 0);
8337 }
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj = 0;
8346 bool arg1 ;
8347 bool val1 ;
8348 int ecode1 = 0 ;
8349 PyObject * obj0 = 0 ;
8350 char * kwnames[] = {
8351 (char *) "flag", NULL
8352 };
8353
8354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8355 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8356 if (!SWIG_IsOK(ecode1)) {
8357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8358 }
8359 arg1 = static_cast< bool >(val1);
8360 {
8361 PyThreadState* __tstate = wxPyBeginAllowThreads();
8362 wxToolTip::Enable(arg1);
8363 wxPyEndAllowThreads(__tstate);
8364 if (PyErr_Occurred()) SWIG_fail;
8365 }
8366 resultobj = SWIG_Py_Void();
8367 return resultobj;
8368 fail:
8369 return NULL;
8370 }
8371
8372
8373 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8374 PyObject *resultobj = 0;
8375 long arg1 ;
8376 long val1 ;
8377 int ecode1 = 0 ;
8378 PyObject * obj0 = 0 ;
8379 char * kwnames[] = {
8380 (char *) "milliseconds", NULL
8381 };
8382
8383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8384 ecode1 = SWIG_AsVal_long(obj0, &val1);
8385 if (!SWIG_IsOK(ecode1)) {
8386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8387 }
8388 arg1 = static_cast< long >(val1);
8389 {
8390 PyThreadState* __tstate = wxPyBeginAllowThreads();
8391 wxToolTip::SetDelay(arg1);
8392 wxPyEndAllowThreads(__tstate);
8393 if (PyErr_Occurred()) SWIG_fail;
8394 }
8395 resultobj = SWIG_Py_Void();
8396 return resultobj;
8397 fail:
8398 return NULL;
8399 }
8400
8401
8402 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8403 PyObject *obj;
8404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8405 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8406 return SWIG_Py_Void();
8407 }
8408
8409 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8410 return SWIG_Python_InitShadowInstance(args);
8411 }
8412
8413 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8414 PyObject *resultobj = 0;
8415 wxWindow *arg1 = (wxWindow *) 0 ;
8416 wxSize *arg2 = 0 ;
8417 wxCaret *result = 0 ;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 wxSize temp2 ;
8421 PyObject * obj0 = 0 ;
8422 PyObject * obj1 = 0 ;
8423 char * kwnames[] = {
8424 (char *) "window",(char *) "size", NULL
8425 };
8426
8427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8429 if (!SWIG_IsOK(res1)) {
8430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8431 }
8432 arg1 = reinterpret_cast< wxWindow * >(argp1);
8433 {
8434 arg2 = &temp2;
8435 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8436 }
8437 {
8438 if (!wxPyCheckForApp()) SWIG_fail;
8439 PyThreadState* __tstate = wxPyBeginAllowThreads();
8440 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8445 return resultobj;
8446 fail:
8447 return NULL;
8448 }
8449
8450
8451 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8452 PyObject *resultobj = 0;
8453 wxCaret *arg1 = (wxCaret *) 0 ;
8454 void *argp1 = 0 ;
8455 int res1 = 0 ;
8456 PyObject *swig_obj[1] ;
8457
8458 if (!args) SWIG_fail;
8459 swig_obj[0] = args;
8460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8461 if (!SWIG_IsOK(res1)) {
8462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8463 }
8464 arg1 = reinterpret_cast< wxCaret * >(argp1);
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 delete arg1;
8468
8469 wxPyEndAllowThreads(__tstate);
8470 if (PyErr_Occurred()) SWIG_fail;
8471 }
8472 resultobj = SWIG_Py_Void();
8473 return resultobj;
8474 fail:
8475 return NULL;
8476 }
8477
8478
8479 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8480 PyObject *resultobj = 0;
8481 wxCaret *arg1 = (wxCaret *) 0 ;
8482 void *argp1 = 0 ;
8483 int res1 = 0 ;
8484 PyObject *swig_obj[1] ;
8485
8486 if (!args) SWIG_fail;
8487 swig_obj[0] = args;
8488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8489 if (!SWIG_IsOK(res1)) {
8490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8491 }
8492 arg1 = reinterpret_cast< wxCaret * >(argp1);
8493 {
8494 PyThreadState* __tstate = wxPyBeginAllowThreads();
8495 wxCaret_Destroy(arg1);
8496 wxPyEndAllowThreads(__tstate);
8497 if (PyErr_Occurred()) SWIG_fail;
8498 }
8499 resultobj = SWIG_Py_Void();
8500 return resultobj;
8501 fail:
8502 return NULL;
8503 }
8504
8505
8506 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8507 PyObject *resultobj = 0;
8508 wxCaret *arg1 = (wxCaret *) 0 ;
8509 bool result;
8510 void *argp1 = 0 ;
8511 int res1 = 0 ;
8512 PyObject *swig_obj[1] ;
8513
8514 if (!args) SWIG_fail;
8515 swig_obj[0] = args;
8516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8517 if (!SWIG_IsOK(res1)) {
8518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8519 }
8520 arg1 = reinterpret_cast< wxCaret * >(argp1);
8521 {
8522 PyThreadState* __tstate = wxPyBeginAllowThreads();
8523 result = (bool)(arg1)->IsOk();
8524 wxPyEndAllowThreads(__tstate);
8525 if (PyErr_Occurred()) SWIG_fail;
8526 }
8527 {
8528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8529 }
8530 return resultobj;
8531 fail:
8532 return NULL;
8533 }
8534
8535
8536 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8537 PyObject *resultobj = 0;
8538 wxCaret *arg1 = (wxCaret *) 0 ;
8539 bool result;
8540 void *argp1 = 0 ;
8541 int res1 = 0 ;
8542 PyObject *swig_obj[1] ;
8543
8544 if (!args) SWIG_fail;
8545 swig_obj[0] = args;
8546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8547 if (!SWIG_IsOK(res1)) {
8548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8549 }
8550 arg1 = reinterpret_cast< wxCaret * >(argp1);
8551 {
8552 PyThreadState* __tstate = wxPyBeginAllowThreads();
8553 result = (bool)(arg1)->IsVisible();
8554 wxPyEndAllowThreads(__tstate);
8555 if (PyErr_Occurred()) SWIG_fail;
8556 }
8557 {
8558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8559 }
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8567 PyObject *resultobj = 0;
8568 wxCaret *arg1 = (wxCaret *) 0 ;
8569 wxPoint result;
8570 void *argp1 = 0 ;
8571 int res1 = 0 ;
8572 PyObject *swig_obj[1] ;
8573
8574 if (!args) SWIG_fail;
8575 swig_obj[0] = args;
8576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8577 if (!SWIG_IsOK(res1)) {
8578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8579 }
8580 arg1 = reinterpret_cast< wxCaret * >(argp1);
8581 {
8582 PyThreadState* __tstate = wxPyBeginAllowThreads();
8583 result = (arg1)->GetPosition();
8584 wxPyEndAllowThreads(__tstate);
8585 if (PyErr_Occurred()) SWIG_fail;
8586 }
8587 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8588 return resultobj;
8589 fail:
8590 return NULL;
8591 }
8592
8593
8594 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8595 PyObject *resultobj = 0;
8596 wxCaret *arg1 = (wxCaret *) 0 ;
8597 int *arg2 = (int *) 0 ;
8598 int *arg3 = (int *) 0 ;
8599 void *argp1 = 0 ;
8600 int res1 = 0 ;
8601 int temp2 ;
8602 int res2 = SWIG_TMPOBJ ;
8603 int temp3 ;
8604 int res3 = SWIG_TMPOBJ ;
8605 PyObject *swig_obj[1] ;
8606
8607 arg2 = &temp2;
8608 arg3 = &temp3;
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_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8614 }
8615 arg1 = reinterpret_cast< wxCaret * >(argp1);
8616 {
8617 PyThreadState* __tstate = wxPyBeginAllowThreads();
8618 (arg1)->GetPosition(arg2,arg3);
8619 wxPyEndAllowThreads(__tstate);
8620 if (PyErr_Occurred()) SWIG_fail;
8621 }
8622 resultobj = SWIG_Py_Void();
8623 if (SWIG_IsTmpObj(res2)) {
8624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8625 } else {
8626 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8627 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8628 }
8629 if (SWIG_IsTmpObj(res3)) {
8630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8631 } else {
8632 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8634 }
8635 return resultobj;
8636 fail:
8637 return NULL;
8638 }
8639
8640
8641 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8642 PyObject *resultobj = 0;
8643 wxCaret *arg1 = (wxCaret *) 0 ;
8644 wxSize result;
8645 void *argp1 = 0 ;
8646 int res1 = 0 ;
8647 PyObject *swig_obj[1] ;
8648
8649 if (!args) SWIG_fail;
8650 swig_obj[0] = args;
8651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8652 if (!SWIG_IsOK(res1)) {
8653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8654 }
8655 arg1 = reinterpret_cast< wxCaret * >(argp1);
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (arg1)->GetSize();
8659 wxPyEndAllowThreads(__tstate);
8660 if (PyErr_Occurred()) SWIG_fail;
8661 }
8662 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8670 PyObject *resultobj = 0;
8671 wxCaret *arg1 = (wxCaret *) 0 ;
8672 int *arg2 = (int *) 0 ;
8673 int *arg3 = (int *) 0 ;
8674 void *argp1 = 0 ;
8675 int res1 = 0 ;
8676 int temp2 ;
8677 int res2 = SWIG_TMPOBJ ;
8678 int temp3 ;
8679 int res3 = SWIG_TMPOBJ ;
8680 PyObject *swig_obj[1] ;
8681
8682 arg2 = &temp2;
8683 arg3 = &temp3;
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_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8689 }
8690 arg1 = reinterpret_cast< wxCaret * >(argp1);
8691 {
8692 PyThreadState* __tstate = wxPyBeginAllowThreads();
8693 (arg1)->GetSize(arg2,arg3);
8694 wxPyEndAllowThreads(__tstate);
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 resultobj = SWIG_Py_Void();
8698 if (SWIG_IsTmpObj(res2)) {
8699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8700 } else {
8701 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8703 }
8704 if (SWIG_IsTmpObj(res3)) {
8705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8706 } else {
8707 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8709 }
8710 return resultobj;
8711 fail:
8712 return NULL;
8713 }
8714
8715
8716 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8717 PyObject *resultobj = 0;
8718 wxCaret *arg1 = (wxCaret *) 0 ;
8719 wxWindow *result = 0 ;
8720 void *argp1 = 0 ;
8721 int res1 = 0 ;
8722 PyObject *swig_obj[1] ;
8723
8724 if (!args) SWIG_fail;
8725 swig_obj[0] = args;
8726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8727 if (!SWIG_IsOK(res1)) {
8728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8729 }
8730 arg1 = reinterpret_cast< wxCaret * >(argp1);
8731 {
8732 PyThreadState* __tstate = wxPyBeginAllowThreads();
8733 result = (wxWindow *)(arg1)->GetWindow();
8734 wxPyEndAllowThreads(__tstate);
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 {
8738 resultobj = wxPyMake_wxObject(result, 0);
8739 }
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8747 PyObject *resultobj = 0;
8748 wxCaret *arg1 = (wxCaret *) 0 ;
8749 int arg2 ;
8750 int arg3 ;
8751 void *argp1 = 0 ;
8752 int res1 = 0 ;
8753 int val2 ;
8754 int ecode2 = 0 ;
8755 int val3 ;
8756 int ecode3 = 0 ;
8757 PyObject * obj0 = 0 ;
8758 PyObject * obj1 = 0 ;
8759 PyObject * obj2 = 0 ;
8760 char * kwnames[] = {
8761 (char *) "self",(char *) "x",(char *) "y", NULL
8762 };
8763
8764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8766 if (!SWIG_IsOK(res1)) {
8767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8768 }
8769 arg1 = reinterpret_cast< wxCaret * >(argp1);
8770 ecode2 = SWIG_AsVal_int(obj1, &val2);
8771 if (!SWIG_IsOK(ecode2)) {
8772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8773 }
8774 arg2 = static_cast< int >(val2);
8775 ecode3 = SWIG_AsVal_int(obj2, &val3);
8776 if (!SWIG_IsOK(ecode3)) {
8777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8778 }
8779 arg3 = static_cast< int >(val3);
8780 {
8781 PyThreadState* __tstate = wxPyBeginAllowThreads();
8782 (arg1)->Move(arg2,arg3);
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 resultobj = SWIG_Py_Void();
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj = 0;
8795 wxCaret *arg1 = (wxCaret *) 0 ;
8796 wxPoint *arg2 = 0 ;
8797 void *argp1 = 0 ;
8798 int res1 = 0 ;
8799 wxPoint temp2 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "pt", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8810 }
8811 arg1 = reinterpret_cast< wxCaret * >(argp1);
8812 {
8813 arg2 = &temp2;
8814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8815 }
8816 {
8817 PyThreadState* __tstate = wxPyBeginAllowThreads();
8818 (arg1)->Move((wxPoint const &)*arg2);
8819 wxPyEndAllowThreads(__tstate);
8820 if (PyErr_Occurred()) SWIG_fail;
8821 }
8822 resultobj = SWIG_Py_Void();
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8830 PyObject *resultobj = 0;
8831 wxCaret *arg1 = (wxCaret *) 0 ;
8832 int arg2 ;
8833 int arg3 ;
8834 void *argp1 = 0 ;
8835 int res1 = 0 ;
8836 int val2 ;
8837 int ecode2 = 0 ;
8838 int val3 ;
8839 int ecode3 = 0 ;
8840 PyObject * obj0 = 0 ;
8841 PyObject * obj1 = 0 ;
8842 PyObject * obj2 = 0 ;
8843 char * kwnames[] = {
8844 (char *) "self",(char *) "width",(char *) "height", NULL
8845 };
8846
8847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8849 if (!SWIG_IsOK(res1)) {
8850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8851 }
8852 arg1 = reinterpret_cast< wxCaret * >(argp1);
8853 ecode2 = SWIG_AsVal_int(obj1, &val2);
8854 if (!SWIG_IsOK(ecode2)) {
8855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8856 }
8857 arg2 = static_cast< int >(val2);
8858 ecode3 = SWIG_AsVal_int(obj2, &val3);
8859 if (!SWIG_IsOK(ecode3)) {
8860 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8861 }
8862 arg3 = static_cast< int >(val3);
8863 {
8864 PyThreadState* __tstate = wxPyBeginAllowThreads();
8865 (arg1)->SetSize(arg2,arg3);
8866 wxPyEndAllowThreads(__tstate);
8867 if (PyErr_Occurred()) SWIG_fail;
8868 }
8869 resultobj = SWIG_Py_Void();
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj = 0;
8878 wxCaret *arg1 = (wxCaret *) 0 ;
8879 wxSize *arg2 = 0 ;
8880 void *argp1 = 0 ;
8881 int res1 = 0 ;
8882 wxSize temp2 ;
8883 PyObject * obj0 = 0 ;
8884 PyObject * obj1 = 0 ;
8885 char * kwnames[] = {
8886 (char *) "self",(char *) "size", NULL
8887 };
8888
8889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8891 if (!SWIG_IsOK(res1)) {
8892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8893 }
8894 arg1 = reinterpret_cast< wxCaret * >(argp1);
8895 {
8896 arg2 = &temp2;
8897 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8898 }
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 (arg1)->SetSize((wxSize const &)*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_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8913 PyObject *resultobj = 0;
8914 wxCaret *arg1 = (wxCaret *) 0 ;
8915 int arg2 = (int) true ;
8916 void *argp1 = 0 ;
8917 int res1 = 0 ;
8918 int val2 ;
8919 int ecode2 = 0 ;
8920 PyObject * obj0 = 0 ;
8921 PyObject * obj1 = 0 ;
8922 char * kwnames[] = {
8923 (char *) "self",(char *) "show", NULL
8924 };
8925
8926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8928 if (!SWIG_IsOK(res1)) {
8929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8930 }
8931 arg1 = reinterpret_cast< wxCaret * >(argp1);
8932 if (obj1) {
8933 ecode2 = SWIG_AsVal_int(obj1, &val2);
8934 if (!SWIG_IsOK(ecode2)) {
8935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8936 }
8937 arg2 = static_cast< int >(val2);
8938 }
8939 {
8940 PyThreadState* __tstate = wxPyBeginAllowThreads();
8941 (arg1)->Show(arg2);
8942 wxPyEndAllowThreads(__tstate);
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 resultobj = SWIG_Py_Void();
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8953 PyObject *resultobj = 0;
8954 wxCaret *arg1 = (wxCaret *) 0 ;
8955 void *argp1 = 0 ;
8956 int res1 = 0 ;
8957 PyObject *swig_obj[1] ;
8958
8959 if (!args) SWIG_fail;
8960 swig_obj[0] = args;
8961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8962 if (!SWIG_IsOK(res1)) {
8963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8964 }
8965 arg1 = reinterpret_cast< wxCaret * >(argp1);
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 (arg1)->Hide();
8969 wxPyEndAllowThreads(__tstate);
8970 if (PyErr_Occurred()) SWIG_fail;
8971 }
8972 resultobj = SWIG_Py_Void();
8973 return resultobj;
8974 fail:
8975 return NULL;
8976 }
8977
8978
8979 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8980 PyObject *resultobj = 0;
8981 int result;
8982
8983 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8984 {
8985 PyThreadState* __tstate = wxPyBeginAllowThreads();
8986 result = (int)wxCaret::GetBlinkTime();
8987 wxPyEndAllowThreads(__tstate);
8988 if (PyErr_Occurred()) SWIG_fail;
8989 }
8990 resultobj = SWIG_From_int(static_cast< int >(result));
8991 return resultobj;
8992 fail:
8993 return NULL;
8994 }
8995
8996
8997 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8998 PyObject *resultobj = 0;
8999 int arg1 ;
9000 int val1 ;
9001 int ecode1 = 0 ;
9002 PyObject * obj0 = 0 ;
9003 char * kwnames[] = {
9004 (char *) "milliseconds", NULL
9005 };
9006
9007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9008 ecode1 = SWIG_AsVal_int(obj0, &val1);
9009 if (!SWIG_IsOK(ecode1)) {
9010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9011 }
9012 arg1 = static_cast< int >(val1);
9013 {
9014 PyThreadState* __tstate = wxPyBeginAllowThreads();
9015 wxCaret::SetBlinkTime(arg1);
9016 wxPyEndAllowThreads(__tstate);
9017 if (PyErr_Occurred()) SWIG_fail;
9018 }
9019 resultobj = SWIG_Py_Void();
9020 return resultobj;
9021 fail:
9022 return NULL;
9023 }
9024
9025
9026 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9027 PyObject *obj;
9028 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9029 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9030 return SWIG_Py_Void();
9031 }
9032
9033 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9034 return SWIG_Python_InitShadowInstance(args);
9035 }
9036
9037 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9038 PyObject *resultobj = 0;
9039 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9040 wxBusyCursor *result = 0 ;
9041 void *argp1 = 0 ;
9042 int res1 = 0 ;
9043 PyObject * obj0 = 0 ;
9044 char * kwnames[] = {
9045 (char *) "cursor", NULL
9046 };
9047
9048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9049 if (obj0) {
9050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9051 if (!SWIG_IsOK(res1)) {
9052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9053 }
9054 arg1 = reinterpret_cast< wxCursor * >(argp1);
9055 }
9056 {
9057 if (!wxPyCheckForApp()) SWIG_fail;
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9060 wxPyEndAllowThreads(__tstate);
9061 if (PyErr_Occurred()) SWIG_fail;
9062 }
9063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9064 return resultobj;
9065 fail:
9066 return NULL;
9067 }
9068
9069
9070 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9071 PyObject *resultobj = 0;
9072 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9073 void *argp1 = 0 ;
9074 int res1 = 0 ;
9075 PyObject *swig_obj[1] ;
9076
9077 if (!args) SWIG_fail;
9078 swig_obj[0] = args;
9079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9080 if (!SWIG_IsOK(res1)) {
9081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9082 }
9083 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 delete arg1;
9087
9088 wxPyEndAllowThreads(__tstate);
9089 if (PyErr_Occurred()) SWIG_fail;
9090 }
9091 resultobj = SWIG_Py_Void();
9092 return resultobj;
9093 fail:
9094 return NULL;
9095 }
9096
9097
9098 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9099 PyObject *obj;
9100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9101 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9102 return SWIG_Py_Void();
9103 }
9104
9105 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9106 return SWIG_Python_InitShadowInstance(args);
9107 }
9108
9109 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9110 PyObject *resultobj = 0;
9111 wxWindow *arg1 = (wxWindow *) NULL ;
9112 wxWindowDisabler *result = 0 ;
9113 void *argp1 = 0 ;
9114 int res1 = 0 ;
9115 PyObject * obj0 = 0 ;
9116 char * kwnames[] = {
9117 (char *) "winToSkip", NULL
9118 };
9119
9120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9121 if (obj0) {
9122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9123 if (!SWIG_IsOK(res1)) {
9124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9125 }
9126 arg1 = reinterpret_cast< wxWindow * >(argp1);
9127 }
9128 {
9129 if (!wxPyCheckForApp()) SWIG_fail;
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9143 PyObject *resultobj = 0;
9144 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9145 void *argp1 = 0 ;
9146 int res1 = 0 ;
9147 PyObject *swig_obj[1] ;
9148
9149 if (!args) SWIG_fail;
9150 swig_obj[0] = args;
9151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9152 if (!SWIG_IsOK(res1)) {
9153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9154 }
9155 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9156 {
9157 PyThreadState* __tstate = wxPyBeginAllowThreads();
9158 delete arg1;
9159
9160 wxPyEndAllowThreads(__tstate);
9161 if (PyErr_Occurred()) SWIG_fail;
9162 }
9163 resultobj = SWIG_Py_Void();
9164 return resultobj;
9165 fail:
9166 return NULL;
9167 }
9168
9169
9170 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9171 PyObject *obj;
9172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9173 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9174 return SWIG_Py_Void();
9175 }
9176
9177 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9178 return SWIG_Python_InitShadowInstance(args);
9179 }
9180
9181 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9182 PyObject *resultobj = 0;
9183 wxString *arg1 = 0 ;
9184 wxBusyInfo *result = 0 ;
9185 bool temp1 = false ;
9186 PyObject * obj0 = 0 ;
9187 char * kwnames[] = {
9188 (char *) "message", NULL
9189 };
9190
9191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9192 {
9193 arg1 = wxString_in_helper(obj0);
9194 if (arg1 == NULL) SWIG_fail;
9195 temp1 = true;
9196 }
9197 {
9198 if (!wxPyCheckForApp()) SWIG_fail;
9199 PyThreadState* __tstate = wxPyBeginAllowThreads();
9200 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9201 wxPyEndAllowThreads(__tstate);
9202 if (PyErr_Occurred()) SWIG_fail;
9203 }
9204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9205 {
9206 if (temp1)
9207 delete arg1;
9208 }
9209 return resultobj;
9210 fail:
9211 {
9212 if (temp1)
9213 delete arg1;
9214 }
9215 return NULL;
9216 }
9217
9218
9219 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9220 PyObject *resultobj = 0;
9221 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9222 void *argp1 = 0 ;
9223 int res1 = 0 ;
9224 PyObject *swig_obj[1] ;
9225
9226 if (!args) SWIG_fail;
9227 swig_obj[0] = args;
9228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9229 if (!SWIG_IsOK(res1)) {
9230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9231 }
9232 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9233 {
9234 PyThreadState* __tstate = wxPyBeginAllowThreads();
9235 delete arg1;
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 resultobj = SWIG_Py_Void();
9241 return resultobj;
9242 fail:
9243 return NULL;
9244 }
9245
9246
9247 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9248 PyObject *obj;
9249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9250 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9251 return SWIG_Py_Void();
9252 }
9253
9254 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9255 return SWIG_Python_InitShadowInstance(args);
9256 }
9257
9258 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9259 PyObject *resultobj = 0;
9260 wxStopWatch *result = 0 ;
9261
9262 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9263 {
9264 PyThreadState* __tstate = wxPyBeginAllowThreads();
9265 result = (wxStopWatch *)new wxStopWatch();
9266 wxPyEndAllowThreads(__tstate);
9267 if (PyErr_Occurred()) SWIG_fail;
9268 }
9269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9270 return resultobj;
9271 fail:
9272 return NULL;
9273 }
9274
9275
9276 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9277 PyObject *resultobj = 0;
9278 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9279 long arg2 = (long) 0 ;
9280 void *argp1 = 0 ;
9281 int res1 = 0 ;
9282 long val2 ;
9283 int ecode2 = 0 ;
9284 PyObject * obj0 = 0 ;
9285 PyObject * obj1 = 0 ;
9286 char * kwnames[] = {
9287 (char *) "self",(char *) "t0", NULL
9288 };
9289
9290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9292 if (!SWIG_IsOK(res1)) {
9293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9294 }
9295 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9296 if (obj1) {
9297 ecode2 = SWIG_AsVal_long(obj1, &val2);
9298 if (!SWIG_IsOK(ecode2)) {
9299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9300 }
9301 arg2 = static_cast< long >(val2);
9302 }
9303 {
9304 PyThreadState* __tstate = wxPyBeginAllowThreads();
9305 (arg1)->Start(arg2);
9306 wxPyEndAllowThreads(__tstate);
9307 if (PyErr_Occurred()) SWIG_fail;
9308 }
9309 resultobj = SWIG_Py_Void();
9310 return resultobj;
9311 fail:
9312 return NULL;
9313 }
9314
9315
9316 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9317 PyObject *resultobj = 0;
9318 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9319 void *argp1 = 0 ;
9320 int res1 = 0 ;
9321 PyObject *swig_obj[1] ;
9322
9323 if (!args) SWIG_fail;
9324 swig_obj[0] = args;
9325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9326 if (!SWIG_IsOK(res1)) {
9327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9328 }
9329 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9330 {
9331 PyThreadState* __tstate = wxPyBeginAllowThreads();
9332 (arg1)->Pause();
9333 wxPyEndAllowThreads(__tstate);
9334 if (PyErr_Occurred()) SWIG_fail;
9335 }
9336 resultobj = SWIG_Py_Void();
9337 return resultobj;
9338 fail:
9339 return NULL;
9340 }
9341
9342
9343 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9344 PyObject *resultobj = 0;
9345 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9346 void *argp1 = 0 ;
9347 int res1 = 0 ;
9348 PyObject *swig_obj[1] ;
9349
9350 if (!args) SWIG_fail;
9351 swig_obj[0] = args;
9352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9353 if (!SWIG_IsOK(res1)) {
9354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9355 }
9356 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 (arg1)->Resume();
9360 wxPyEndAllowThreads(__tstate);
9361 if (PyErr_Occurred()) SWIG_fail;
9362 }
9363 resultobj = SWIG_Py_Void();
9364 return resultobj;
9365 fail:
9366 return NULL;
9367 }
9368
9369
9370 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9371 PyObject *resultobj = 0;
9372 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9373 long result;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 PyObject *swig_obj[1] ;
9377
9378 if (!args) SWIG_fail;
9379 swig_obj[0] = args;
9380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9381 if (!SWIG_IsOK(res1)) {
9382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9383 }
9384 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9385 {
9386 PyThreadState* __tstate = wxPyBeginAllowThreads();
9387 result = (long)((wxStopWatch const *)arg1)->Time();
9388 wxPyEndAllowThreads(__tstate);
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 resultobj = SWIG_From_long(static_cast< long >(result));
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9399 PyObject *obj;
9400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9401 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9402 return SWIG_Py_Void();
9403 }
9404
9405 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9406 return SWIG_Python_InitShadowInstance(args);
9407 }
9408
9409 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9410 PyObject *resultobj = 0;
9411 int arg1 = (int) 9 ;
9412 int arg2 = (int) wxID_FILE1 ;
9413 wxFileHistory *result = 0 ;
9414 int val1 ;
9415 int ecode1 = 0 ;
9416 int val2 ;
9417 int ecode2 = 0 ;
9418 PyObject * obj0 = 0 ;
9419 PyObject * obj1 = 0 ;
9420 char * kwnames[] = {
9421 (char *) "maxFiles",(char *) "idBase", NULL
9422 };
9423
9424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9425 if (obj0) {
9426 ecode1 = SWIG_AsVal_int(obj0, &val1);
9427 if (!SWIG_IsOK(ecode1)) {
9428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9429 }
9430 arg1 = static_cast< int >(val1);
9431 }
9432 if (obj1) {
9433 ecode2 = SWIG_AsVal_int(obj1, &val2);
9434 if (!SWIG_IsOK(ecode2)) {
9435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9436 }
9437 arg2 = static_cast< int >(val2);
9438 }
9439 {
9440 PyThreadState* __tstate = wxPyBeginAllowThreads();
9441 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9446 return resultobj;
9447 fail:
9448 return NULL;
9449 }
9450
9451
9452 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9453 PyObject *resultobj = 0;
9454 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9455 void *argp1 = 0 ;
9456 int res1 = 0 ;
9457 PyObject *swig_obj[1] ;
9458
9459 if (!args) SWIG_fail;
9460 swig_obj[0] = args;
9461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9464 }
9465 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9466 {
9467 PyThreadState* __tstate = wxPyBeginAllowThreads();
9468 delete arg1;
9469
9470 wxPyEndAllowThreads(__tstate);
9471 if (PyErr_Occurred()) SWIG_fail;
9472 }
9473 resultobj = SWIG_Py_Void();
9474 return resultobj;
9475 fail:
9476 return NULL;
9477 }
9478
9479
9480 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9481 PyObject *resultobj = 0;
9482 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9483 wxString *arg2 = 0 ;
9484 void *argp1 = 0 ;
9485 int res1 = 0 ;
9486 bool temp2 = false ;
9487 PyObject * obj0 = 0 ;
9488 PyObject * obj1 = 0 ;
9489 char * kwnames[] = {
9490 (char *) "self",(char *) "file", NULL
9491 };
9492
9493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9495 if (!SWIG_IsOK(res1)) {
9496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9497 }
9498 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9499 {
9500 arg2 = wxString_in_helper(obj1);
9501 if (arg2 == NULL) SWIG_fail;
9502 temp2 = true;
9503 }
9504 {
9505 PyThreadState* __tstate = wxPyBeginAllowThreads();
9506 (arg1)->AddFileToHistory((wxString const &)*arg2);
9507 wxPyEndAllowThreads(__tstate);
9508 if (PyErr_Occurred()) SWIG_fail;
9509 }
9510 resultobj = SWIG_Py_Void();
9511 {
9512 if (temp2)
9513 delete arg2;
9514 }
9515 return resultobj;
9516 fail:
9517 {
9518 if (temp2)
9519 delete arg2;
9520 }
9521 return NULL;
9522 }
9523
9524
9525 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9526 PyObject *resultobj = 0;
9527 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9528 int arg2 ;
9529 void *argp1 = 0 ;
9530 int res1 = 0 ;
9531 int val2 ;
9532 int ecode2 = 0 ;
9533 PyObject * obj0 = 0 ;
9534 PyObject * obj1 = 0 ;
9535 char * kwnames[] = {
9536 (char *) "self",(char *) "i", NULL
9537 };
9538
9539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9541 if (!SWIG_IsOK(res1)) {
9542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9543 }
9544 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9545 ecode2 = SWIG_AsVal_int(obj1, &val2);
9546 if (!SWIG_IsOK(ecode2)) {
9547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9548 }
9549 arg2 = static_cast< int >(val2);
9550 {
9551 PyThreadState* __tstate = wxPyBeginAllowThreads();
9552 (arg1)->RemoveFileFromHistory(arg2);
9553 wxPyEndAllowThreads(__tstate);
9554 if (PyErr_Occurred()) SWIG_fail;
9555 }
9556 resultobj = SWIG_Py_Void();
9557 return resultobj;
9558 fail:
9559 return NULL;
9560 }
9561
9562
9563 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9564 PyObject *resultobj = 0;
9565 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9566 int result;
9567 void *argp1 = 0 ;
9568 int res1 = 0 ;
9569 PyObject *swig_obj[1] ;
9570
9571 if (!args) SWIG_fail;
9572 swig_obj[0] = args;
9573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9574 if (!SWIG_IsOK(res1)) {
9575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9576 }
9577 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9578 {
9579 PyThreadState* __tstate = wxPyBeginAllowThreads();
9580 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9581 wxPyEndAllowThreads(__tstate);
9582 if (PyErr_Occurred()) SWIG_fail;
9583 }
9584 resultobj = SWIG_From_int(static_cast< int >(result));
9585 return resultobj;
9586 fail:
9587 return NULL;
9588 }
9589
9590
9591 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9592 PyObject *resultobj = 0;
9593 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9594 wxMenu *arg2 = (wxMenu *) 0 ;
9595 void *argp1 = 0 ;
9596 int res1 = 0 ;
9597 void *argp2 = 0 ;
9598 int res2 = 0 ;
9599 PyObject * obj0 = 0 ;
9600 PyObject * obj1 = 0 ;
9601 char * kwnames[] = {
9602 (char *) "self",(char *) "menu", NULL
9603 };
9604
9605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9607 if (!SWIG_IsOK(res1)) {
9608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9609 }
9610 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9611 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9612 if (!SWIG_IsOK(res2)) {
9613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9614 }
9615 arg2 = reinterpret_cast< wxMenu * >(argp2);
9616 {
9617 PyThreadState* __tstate = wxPyBeginAllowThreads();
9618 (arg1)->UseMenu(arg2);
9619 wxPyEndAllowThreads(__tstate);
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 resultobj = SWIG_Py_Void();
9623 return resultobj;
9624 fail:
9625 return NULL;
9626 }
9627
9628
9629 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9630 PyObject *resultobj = 0;
9631 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9632 wxMenu *arg2 = (wxMenu *) 0 ;
9633 void *argp1 = 0 ;
9634 int res1 = 0 ;
9635 void *argp2 = 0 ;
9636 int res2 = 0 ;
9637 PyObject * obj0 = 0 ;
9638 PyObject * obj1 = 0 ;
9639 char * kwnames[] = {
9640 (char *) "self",(char *) "menu", NULL
9641 };
9642
9643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9645 if (!SWIG_IsOK(res1)) {
9646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9647 }
9648 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9649 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9650 if (!SWIG_IsOK(res2)) {
9651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9652 }
9653 arg2 = reinterpret_cast< wxMenu * >(argp2);
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 (arg1)->RemoveMenu(arg2);
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_Py_Void();
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9668 PyObject *resultobj = 0;
9669 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9670 wxConfigBase *arg2 = 0 ;
9671 void *argp1 = 0 ;
9672 int res1 = 0 ;
9673 void *argp2 = 0 ;
9674 int res2 = 0 ;
9675 PyObject * obj0 = 0 ;
9676 PyObject * obj1 = 0 ;
9677 char * kwnames[] = {
9678 (char *) "self",(char *) "config", NULL
9679 };
9680
9681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9683 if (!SWIG_IsOK(res1)) {
9684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9685 }
9686 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9687 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9688 if (!SWIG_IsOK(res2)) {
9689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9690 }
9691 if (!argp2) {
9692 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9693 }
9694 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 (arg1)->Load(*arg2);
9698 wxPyEndAllowThreads(__tstate);
9699 if (PyErr_Occurred()) SWIG_fail;
9700 }
9701 resultobj = SWIG_Py_Void();
9702 return resultobj;
9703 fail:
9704 return NULL;
9705 }
9706
9707
9708 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9709 PyObject *resultobj = 0;
9710 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9711 wxConfigBase *arg2 = 0 ;
9712 void *argp1 = 0 ;
9713 int res1 = 0 ;
9714 void *argp2 = 0 ;
9715 int res2 = 0 ;
9716 PyObject * obj0 = 0 ;
9717 PyObject * obj1 = 0 ;
9718 char * kwnames[] = {
9719 (char *) "self",(char *) "config", NULL
9720 };
9721
9722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9724 if (!SWIG_IsOK(res1)) {
9725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9726 }
9727 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9728 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9729 if (!SWIG_IsOK(res2)) {
9730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9731 }
9732 if (!argp2) {
9733 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9734 }
9735 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9736 {
9737 PyThreadState* __tstate = wxPyBeginAllowThreads();
9738 (arg1)->Save(*arg2);
9739 wxPyEndAllowThreads(__tstate);
9740 if (PyErr_Occurred()) SWIG_fail;
9741 }
9742 resultobj = SWIG_Py_Void();
9743 return resultobj;
9744 fail:
9745 return NULL;
9746 }
9747
9748
9749 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9750 PyObject *resultobj = 0;
9751 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9752 void *argp1 = 0 ;
9753 int res1 = 0 ;
9754 PyObject *swig_obj[1] ;
9755
9756 if (!args) SWIG_fail;
9757 swig_obj[0] = args;
9758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9759 if (!SWIG_IsOK(res1)) {
9760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9761 }
9762 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9763 {
9764 PyThreadState* __tstate = wxPyBeginAllowThreads();
9765 (arg1)->AddFilesToMenu();
9766 wxPyEndAllowThreads(__tstate);
9767 if (PyErr_Occurred()) SWIG_fail;
9768 }
9769 resultobj = SWIG_Py_Void();
9770 return resultobj;
9771 fail:
9772 return NULL;
9773 }
9774
9775
9776 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9777 PyObject *resultobj = 0;
9778 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9779 wxMenu *arg2 = (wxMenu *) 0 ;
9780 void *argp1 = 0 ;
9781 int res1 = 0 ;
9782 void *argp2 = 0 ;
9783 int res2 = 0 ;
9784 PyObject * obj0 = 0 ;
9785 PyObject * obj1 = 0 ;
9786 char * kwnames[] = {
9787 (char *) "self",(char *) "menu", NULL
9788 };
9789
9790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9792 if (!SWIG_IsOK(res1)) {
9793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9794 }
9795 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9796 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9797 if (!SWIG_IsOK(res2)) {
9798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9799 }
9800 arg2 = reinterpret_cast< wxMenu * >(argp2);
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 (arg1)->AddFilesToMenu(arg2);
9804 wxPyEndAllowThreads(__tstate);
9805 if (PyErr_Occurred()) SWIG_fail;
9806 }
9807 resultobj = SWIG_Py_Void();
9808 return resultobj;
9809 fail:
9810 return NULL;
9811 }
9812
9813
9814 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9815 PyObject *resultobj = 0;
9816 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9817 int arg2 ;
9818 wxString result;
9819 void *argp1 = 0 ;
9820 int res1 = 0 ;
9821 int val2 ;
9822 int ecode2 = 0 ;
9823 PyObject * obj0 = 0 ;
9824 PyObject * obj1 = 0 ;
9825 char * kwnames[] = {
9826 (char *) "self",(char *) "i", NULL
9827 };
9828
9829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9831 if (!SWIG_IsOK(res1)) {
9832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9833 }
9834 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9835 ecode2 = SWIG_AsVal_int(obj1, &val2);
9836 if (!SWIG_IsOK(ecode2)) {
9837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9838 }
9839 arg2 = static_cast< int >(val2);
9840 {
9841 PyThreadState* __tstate = wxPyBeginAllowThreads();
9842 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9843 wxPyEndAllowThreads(__tstate);
9844 if (PyErr_Occurred()) SWIG_fail;
9845 }
9846 {
9847 #if wxUSE_UNICODE
9848 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9849 #else
9850 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9851 #endif
9852 }
9853 return resultobj;
9854 fail:
9855 return NULL;
9856 }
9857
9858
9859 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9860 PyObject *resultobj = 0;
9861 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9862 int result;
9863 void *argp1 = 0 ;
9864 int res1 = 0 ;
9865 PyObject *swig_obj[1] ;
9866
9867 if (!args) SWIG_fail;
9868 swig_obj[0] = args;
9869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9870 if (!SWIG_IsOK(res1)) {
9871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9872 }
9873 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9874 {
9875 PyThreadState* __tstate = wxPyBeginAllowThreads();
9876 result = (int)((wxFileHistory const *)arg1)->GetCount();
9877 wxPyEndAllowThreads(__tstate);
9878 if (PyErr_Occurred()) SWIG_fail;
9879 }
9880 resultobj = SWIG_From_int(static_cast< int >(result));
9881 return resultobj;
9882 fail:
9883 return NULL;
9884 }
9885
9886
9887 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9888 PyObject *obj;
9889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9890 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9891 return SWIG_Py_Void();
9892 }
9893
9894 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9895 return SWIG_Python_InitShadowInstance(args);
9896 }
9897
9898 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9899 PyObject *resultobj = 0;
9900 wxString *arg1 = 0 ;
9901 wxString const &arg2_defvalue = wxPyEmptyString ;
9902 wxString *arg2 = (wxString *) &arg2_defvalue ;
9903 wxSingleInstanceChecker *result = 0 ;
9904 bool temp1 = false ;
9905 bool temp2 = false ;
9906 PyObject * obj0 = 0 ;
9907 PyObject * obj1 = 0 ;
9908 char * kwnames[] = {
9909 (char *) "name",(char *) "path", NULL
9910 };
9911
9912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9913 {
9914 arg1 = wxString_in_helper(obj0);
9915 if (arg1 == NULL) SWIG_fail;
9916 temp1 = true;
9917 }
9918 if (obj1) {
9919 {
9920 arg2 = wxString_in_helper(obj1);
9921 if (arg2 == NULL) SWIG_fail;
9922 temp2 = true;
9923 }
9924 }
9925 {
9926 PyThreadState* __tstate = wxPyBeginAllowThreads();
9927 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9928 wxPyEndAllowThreads(__tstate);
9929 if (PyErr_Occurred()) SWIG_fail;
9930 }
9931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9932 {
9933 if (temp1)
9934 delete arg1;
9935 }
9936 {
9937 if (temp2)
9938 delete arg2;
9939 }
9940 return resultobj;
9941 fail:
9942 {
9943 if (temp1)
9944 delete arg1;
9945 }
9946 {
9947 if (temp2)
9948 delete arg2;
9949 }
9950 return NULL;
9951 }
9952
9953
9954 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9955 PyObject *resultobj = 0;
9956 wxSingleInstanceChecker *result = 0 ;
9957
9958 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9959 {
9960 PyThreadState* __tstate = wxPyBeginAllowThreads();
9961 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9962 wxPyEndAllowThreads(__tstate);
9963 if (PyErr_Occurred()) SWIG_fail;
9964 }
9965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9966 return resultobj;
9967 fail:
9968 return NULL;
9969 }
9970
9971
9972 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9973 PyObject *resultobj = 0;
9974 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9975 void *argp1 = 0 ;
9976 int res1 = 0 ;
9977 PyObject *swig_obj[1] ;
9978
9979 if (!args) SWIG_fail;
9980 swig_obj[0] = args;
9981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9982 if (!SWIG_IsOK(res1)) {
9983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9984 }
9985 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9986 {
9987 PyThreadState* __tstate = wxPyBeginAllowThreads();
9988 delete arg1;
9989
9990 wxPyEndAllowThreads(__tstate);
9991 if (PyErr_Occurred()) SWIG_fail;
9992 }
9993 resultobj = SWIG_Py_Void();
9994 return resultobj;
9995 fail:
9996 return NULL;
9997 }
9998
9999
10000 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10001 PyObject *resultobj = 0;
10002 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10003 wxString *arg2 = 0 ;
10004 wxString const &arg3_defvalue = wxPyEmptyString ;
10005 wxString *arg3 = (wxString *) &arg3_defvalue ;
10006 bool result;
10007 void *argp1 = 0 ;
10008 int res1 = 0 ;
10009 bool temp2 = false ;
10010 bool temp3 = false ;
10011 PyObject * obj0 = 0 ;
10012 PyObject * obj1 = 0 ;
10013 PyObject * obj2 = 0 ;
10014 char * kwnames[] = {
10015 (char *) "self",(char *) "name",(char *) "path", NULL
10016 };
10017
10018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10020 if (!SWIG_IsOK(res1)) {
10021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10022 }
10023 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10024 {
10025 arg2 = wxString_in_helper(obj1);
10026 if (arg2 == NULL) SWIG_fail;
10027 temp2 = true;
10028 }
10029 if (obj2) {
10030 {
10031 arg3 = wxString_in_helper(obj2);
10032 if (arg3 == NULL) SWIG_fail;
10033 temp3 = true;
10034 }
10035 }
10036 {
10037 PyThreadState* __tstate = wxPyBeginAllowThreads();
10038 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10039 wxPyEndAllowThreads(__tstate);
10040 if (PyErr_Occurred()) SWIG_fail;
10041 }
10042 {
10043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10044 }
10045 {
10046 if (temp2)
10047 delete arg2;
10048 }
10049 {
10050 if (temp3)
10051 delete arg3;
10052 }
10053 return resultobj;
10054 fail:
10055 {
10056 if (temp2)
10057 delete arg2;
10058 }
10059 {
10060 if (temp3)
10061 delete arg3;
10062 }
10063 return NULL;
10064 }
10065
10066
10067 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10068 PyObject *resultobj = 0;
10069 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10070 bool result;
10071 void *argp1 = 0 ;
10072 int res1 = 0 ;
10073 PyObject *swig_obj[1] ;
10074
10075 if (!args) SWIG_fail;
10076 swig_obj[0] = args;
10077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10078 if (!SWIG_IsOK(res1)) {
10079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10080 }
10081 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10082 {
10083 PyThreadState* __tstate = wxPyBeginAllowThreads();
10084 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10085 wxPyEndAllowThreads(__tstate);
10086 if (PyErr_Occurred()) SWIG_fail;
10087 }
10088 {
10089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10090 }
10091 return resultobj;
10092 fail:
10093 return NULL;
10094 }
10095
10096
10097 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10098 PyObject *obj;
10099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10100 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10101 return SWIG_Py_Void();
10102 }
10103
10104 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10105 return SWIG_Python_InitShadowInstance(args);
10106 }
10107
10108 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10109 PyObject *resultobj = 0;
10110 wxPlatformInfo *result = 0 ;
10111
10112 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10113 {
10114 PyThreadState* __tstate = wxPyBeginAllowThreads();
10115 result = (wxPlatformInfo *)new wxPlatformInfo();
10116 wxPyEndAllowThreads(__tstate);
10117 if (PyErr_Occurred()) SWIG_fail;
10118 }
10119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10120 return resultobj;
10121 fail:
10122 return NULL;
10123 }
10124
10125
10126 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10127 PyObject *resultobj = 0;
10128 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10129 wxPlatformInfo *arg2 = 0 ;
10130 bool result;
10131 void *argp1 = 0 ;
10132 int res1 = 0 ;
10133 void *argp2 = 0 ;
10134 int res2 = 0 ;
10135 PyObject * obj0 = 0 ;
10136 PyObject * obj1 = 0 ;
10137 char * kwnames[] = {
10138 (char *) "self",(char *) "t", NULL
10139 };
10140
10141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10143 if (!SWIG_IsOK(res1)) {
10144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10145 }
10146 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10148 if (!SWIG_IsOK(res2)) {
10149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10150 }
10151 if (!argp2) {
10152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10153 }
10154 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 {
10162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10163 }
10164 return resultobj;
10165 fail:
10166 return NULL;
10167 }
10168
10169
10170 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10171 PyObject *resultobj = 0;
10172 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10173 wxPlatformInfo *arg2 = 0 ;
10174 bool result;
10175 void *argp1 = 0 ;
10176 int res1 = 0 ;
10177 void *argp2 = 0 ;
10178 int res2 = 0 ;
10179 PyObject * obj0 = 0 ;
10180 PyObject * obj1 = 0 ;
10181 char * kwnames[] = {
10182 (char *) "self",(char *) "t", NULL
10183 };
10184
10185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10187 if (!SWIG_IsOK(res1)) {
10188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10189 }
10190 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10191 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10192 if (!SWIG_IsOK(res2)) {
10193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10194 }
10195 if (!argp2) {
10196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10197 }
10198 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10199 {
10200 PyThreadState* __tstate = wxPyBeginAllowThreads();
10201 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10202 wxPyEndAllowThreads(__tstate);
10203 if (PyErr_Occurred()) SWIG_fail;
10204 }
10205 {
10206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10207 }
10208 return resultobj;
10209 fail:
10210 return NULL;
10211 }
10212
10213
10214 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10215 PyObject *resultobj = 0;
10216 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10217 int result;
10218 void *argp1 = 0 ;
10219 int res1 = 0 ;
10220 PyObject *swig_obj[1] ;
10221
10222 if (!args) SWIG_fail;
10223 swig_obj[0] = args;
10224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10225 if (!SWIG_IsOK(res1)) {
10226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10227 }
10228 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10229 {
10230 PyThreadState* __tstate = wxPyBeginAllowThreads();
10231 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10232 wxPyEndAllowThreads(__tstate);
10233 if (PyErr_Occurred()) SWIG_fail;
10234 }
10235 resultobj = SWIG_From_int(static_cast< int >(result));
10236 return resultobj;
10237 fail:
10238 return NULL;
10239 }
10240
10241
10242 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10243 PyObject *resultobj = 0;
10244 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10245 int result;
10246 void *argp1 = 0 ;
10247 int res1 = 0 ;
10248 PyObject *swig_obj[1] ;
10249
10250 if (!args) SWIG_fail;
10251 swig_obj[0] = args;
10252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10253 if (!SWIG_IsOK(res1)) {
10254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10255 }
10256 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10257 {
10258 PyThreadState* __tstate = wxPyBeginAllowThreads();
10259 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10260 wxPyEndAllowThreads(__tstate);
10261 if (PyErr_Occurred()) SWIG_fail;
10262 }
10263 resultobj = SWIG_From_int(static_cast< int >(result));
10264 return resultobj;
10265 fail:
10266 return NULL;
10267 }
10268
10269
10270 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10271 PyObject *resultobj = 0;
10272 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10273 int arg2 ;
10274 int arg3 ;
10275 bool result;
10276 void *argp1 = 0 ;
10277 int res1 = 0 ;
10278 int val2 ;
10279 int ecode2 = 0 ;
10280 int val3 ;
10281 int ecode3 = 0 ;
10282 PyObject * obj0 = 0 ;
10283 PyObject * obj1 = 0 ;
10284 PyObject * obj2 = 0 ;
10285 char * kwnames[] = {
10286 (char *) "self",(char *) "major",(char *) "minor", NULL
10287 };
10288
10289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10291 if (!SWIG_IsOK(res1)) {
10292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10293 }
10294 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10295 ecode2 = SWIG_AsVal_int(obj1, &val2);
10296 if (!SWIG_IsOK(ecode2)) {
10297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10298 }
10299 arg2 = static_cast< int >(val2);
10300 ecode3 = SWIG_AsVal_int(obj2, &val3);
10301 if (!SWIG_IsOK(ecode3)) {
10302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10303 }
10304 arg3 = static_cast< int >(val3);
10305 {
10306 PyThreadState* __tstate = wxPyBeginAllowThreads();
10307 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10308 wxPyEndAllowThreads(__tstate);
10309 if (PyErr_Occurred()) SWIG_fail;
10310 }
10311 {
10312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10313 }
10314 return resultobj;
10315 fail:
10316 return NULL;
10317 }
10318
10319
10320 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10321 PyObject *resultobj = 0;
10322 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10323 int result;
10324 void *argp1 = 0 ;
10325 int res1 = 0 ;
10326 PyObject *swig_obj[1] ;
10327
10328 if (!args) SWIG_fail;
10329 swig_obj[0] = args;
10330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10331 if (!SWIG_IsOK(res1)) {
10332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10333 }
10334 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10335 {
10336 PyThreadState* __tstate = wxPyBeginAllowThreads();
10337 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10338 wxPyEndAllowThreads(__tstate);
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 resultobj = SWIG_From_int(static_cast< int >(result));
10342 return resultobj;
10343 fail:
10344 return NULL;
10345 }
10346
10347
10348 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10349 PyObject *resultobj = 0;
10350 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10351 int result;
10352 void *argp1 = 0 ;
10353 int res1 = 0 ;
10354 PyObject *swig_obj[1] ;
10355
10356 if (!args) SWIG_fail;
10357 swig_obj[0] = args;
10358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10359 if (!SWIG_IsOK(res1)) {
10360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10361 }
10362 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10366 wxPyEndAllowThreads(__tstate);
10367 if (PyErr_Occurred()) SWIG_fail;
10368 }
10369 resultobj = SWIG_From_int(static_cast< int >(result));
10370 return resultobj;
10371 fail:
10372 return NULL;
10373 }
10374
10375
10376 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10377 PyObject *resultobj = 0;
10378 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10379 int arg2 ;
10380 int arg3 ;
10381 bool result;
10382 void *argp1 = 0 ;
10383 int res1 = 0 ;
10384 int val2 ;
10385 int ecode2 = 0 ;
10386 int val3 ;
10387 int ecode3 = 0 ;
10388 PyObject * obj0 = 0 ;
10389 PyObject * obj1 = 0 ;
10390 PyObject * obj2 = 0 ;
10391 char * kwnames[] = {
10392 (char *) "self",(char *) "major",(char *) "minor", NULL
10393 };
10394
10395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10397 if (!SWIG_IsOK(res1)) {
10398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10399 }
10400 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10401 ecode2 = SWIG_AsVal_int(obj1, &val2);
10402 if (!SWIG_IsOK(ecode2)) {
10403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10404 }
10405 arg2 = static_cast< int >(val2);
10406 ecode3 = SWIG_AsVal_int(obj2, &val3);
10407 if (!SWIG_IsOK(ecode3)) {
10408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10409 }
10410 arg3 = static_cast< int >(val3);
10411 {
10412 PyThreadState* __tstate = wxPyBeginAllowThreads();
10413 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10414 wxPyEndAllowThreads(__tstate);
10415 if (PyErr_Occurred()) SWIG_fail;
10416 }
10417 {
10418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10419 }
10420 return resultobj;
10421 fail:
10422 return NULL;
10423 }
10424
10425
10426 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10427 PyObject *resultobj = 0;
10428 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10429 bool result;
10430 void *argp1 = 0 ;
10431 int res1 = 0 ;
10432 PyObject *swig_obj[1] ;
10433
10434 if (!args) SWIG_fail;
10435 swig_obj[0] = args;
10436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10437 if (!SWIG_IsOK(res1)) {
10438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10439 }
10440 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10441 {
10442 PyThreadState* __tstate = wxPyBeginAllowThreads();
10443 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10444 wxPyEndAllowThreads(__tstate);
10445 if (PyErr_Occurred()) SWIG_fail;
10446 }
10447 {
10448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10449 }
10450 return resultobj;
10451 fail:
10452 return NULL;
10453 }
10454
10455
10456 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10457 PyObject *resultobj = 0;
10458 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10459 wxOperatingSystemId result;
10460 void *argp1 = 0 ;
10461 int res1 = 0 ;
10462 PyObject *swig_obj[1] ;
10463
10464 if (!args) SWIG_fail;
10465 swig_obj[0] = args;
10466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10467 if (!SWIG_IsOK(res1)) {
10468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10469 }
10470 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10471 {
10472 PyThreadState* __tstate = wxPyBeginAllowThreads();
10473 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10474 wxPyEndAllowThreads(__tstate);
10475 if (PyErr_Occurred()) SWIG_fail;
10476 }
10477 resultobj = SWIG_From_int(static_cast< int >(result));
10478 return resultobj;
10479 fail:
10480 return NULL;
10481 }
10482
10483
10484 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10485 PyObject *resultobj = 0;
10486 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10487 wxPortId result;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 PyObject *swig_obj[1] ;
10491
10492 if (!args) SWIG_fail;
10493 swig_obj[0] = args;
10494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10495 if (!SWIG_IsOK(res1)) {
10496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10497 }
10498 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 resultobj = SWIG_From_int(static_cast< int >(result));
10506 return resultobj;
10507 fail:
10508 return NULL;
10509 }
10510
10511
10512 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10513 PyObject *resultobj = 0;
10514 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10515 wxArchitecture result;
10516 void *argp1 = 0 ;
10517 int res1 = 0 ;
10518 PyObject *swig_obj[1] ;
10519
10520 if (!args) SWIG_fail;
10521 swig_obj[0] = args;
10522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10523 if (!SWIG_IsOK(res1)) {
10524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10525 }
10526 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10527 {
10528 PyThreadState* __tstate = wxPyBeginAllowThreads();
10529 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10530 wxPyEndAllowThreads(__tstate);
10531 if (PyErr_Occurred()) SWIG_fail;
10532 }
10533 resultobj = SWIG_From_int(static_cast< int >(result));
10534 return resultobj;
10535 fail:
10536 return NULL;
10537 }
10538
10539
10540 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10541 PyObject *resultobj = 0;
10542 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10543 wxEndianness result;
10544 void *argp1 = 0 ;
10545 int res1 = 0 ;
10546 PyObject *swig_obj[1] ;
10547
10548 if (!args) SWIG_fail;
10549 swig_obj[0] = args;
10550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10553 }
10554 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_From_int(static_cast< int >(result));
10562 return resultobj;
10563 fail:
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *resultobj = 0;
10570 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10571 wxString result;
10572 void *argp1 = 0 ;
10573 int res1 = 0 ;
10574 PyObject *swig_obj[1] ;
10575
10576 if (!args) SWIG_fail;
10577 swig_obj[0] = args;
10578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10579 if (!SWIG_IsOK(res1)) {
10580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10581 }
10582 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 {
10590 #if wxUSE_UNICODE
10591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10592 #else
10593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10594 #endif
10595 }
10596 return resultobj;
10597 fail:
10598 return NULL;
10599 }
10600
10601
10602 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10603 PyObject *resultobj = 0;
10604 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10605 wxString result;
10606 void *argp1 = 0 ;
10607 int res1 = 0 ;
10608 PyObject *swig_obj[1] ;
10609
10610 if (!args) SWIG_fail;
10611 swig_obj[0] = args;
10612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10613 if (!SWIG_IsOK(res1)) {
10614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10615 }
10616 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10617 {
10618 PyThreadState* __tstate = wxPyBeginAllowThreads();
10619 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10620 wxPyEndAllowThreads(__tstate);
10621 if (PyErr_Occurred()) SWIG_fail;
10622 }
10623 {
10624 #if wxUSE_UNICODE
10625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10626 #else
10627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10628 #endif
10629 }
10630 return resultobj;
10631 fail:
10632 return NULL;
10633 }
10634
10635
10636 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10637 PyObject *resultobj = 0;
10638 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10639 wxString result;
10640 void *argp1 = 0 ;
10641 int res1 = 0 ;
10642 PyObject *swig_obj[1] ;
10643
10644 if (!args) SWIG_fail;
10645 swig_obj[0] = args;
10646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10647 if (!SWIG_IsOK(res1)) {
10648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10649 }
10650 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10651 {
10652 PyThreadState* __tstate = wxPyBeginAllowThreads();
10653 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10654 wxPyEndAllowThreads(__tstate);
10655 if (PyErr_Occurred()) SWIG_fail;
10656 }
10657 {
10658 #if wxUSE_UNICODE
10659 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10660 #else
10661 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10662 #endif
10663 }
10664 return resultobj;
10665 fail:
10666 return NULL;
10667 }
10668
10669
10670 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10671 PyObject *resultobj = 0;
10672 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10673 wxString result;
10674 void *argp1 = 0 ;
10675 int res1 = 0 ;
10676 PyObject *swig_obj[1] ;
10677
10678 if (!args) SWIG_fail;
10679 swig_obj[0] = args;
10680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10681 if (!SWIG_IsOK(res1)) {
10682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10683 }
10684 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10685 {
10686 PyThreadState* __tstate = wxPyBeginAllowThreads();
10687 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 {
10692 #if wxUSE_UNICODE
10693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10694 #else
10695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10696 #endif
10697 }
10698 return resultobj;
10699 fail:
10700 return NULL;
10701 }
10702
10703
10704 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10705 PyObject *resultobj = 0;
10706 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10707 wxString result;
10708 void *argp1 = 0 ;
10709 int res1 = 0 ;
10710 PyObject *swig_obj[1] ;
10711
10712 if (!args) SWIG_fail;
10713 swig_obj[0] = args;
10714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10715 if (!SWIG_IsOK(res1)) {
10716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10717 }
10718 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10719 {
10720 PyThreadState* __tstate = wxPyBeginAllowThreads();
10721 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10722 wxPyEndAllowThreads(__tstate);
10723 if (PyErr_Occurred()) SWIG_fail;
10724 }
10725 {
10726 #if wxUSE_UNICODE
10727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10728 #else
10729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10730 #endif
10731 }
10732 return resultobj;
10733 fail:
10734 return NULL;
10735 }
10736
10737
10738 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10739 PyObject *resultobj = 0;
10740 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10741 wxString result;
10742 void *argp1 = 0 ;
10743 int res1 = 0 ;
10744 PyObject *swig_obj[1] ;
10745
10746 if (!args) SWIG_fail;
10747 swig_obj[0] = args;
10748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10749 if (!SWIG_IsOK(res1)) {
10750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10751 }
10752 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10753 {
10754 PyThreadState* __tstate = wxPyBeginAllowThreads();
10755 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10756 wxPyEndAllowThreads(__tstate);
10757 if (PyErr_Occurred()) SWIG_fail;
10758 }
10759 {
10760 #if wxUSE_UNICODE
10761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10762 #else
10763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10764 #endif
10765 }
10766 return resultobj;
10767 fail:
10768 return NULL;
10769 }
10770
10771
10772 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10773 PyObject *resultobj = 0;
10774 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10775 int arg2 ;
10776 int arg3 ;
10777 void *argp1 = 0 ;
10778 int res1 = 0 ;
10779 int val2 ;
10780 int ecode2 = 0 ;
10781 int val3 ;
10782 int ecode3 = 0 ;
10783 PyObject * obj0 = 0 ;
10784 PyObject * obj1 = 0 ;
10785 PyObject * obj2 = 0 ;
10786 char * kwnames[] = {
10787 (char *) "self",(char *) "major",(char *) "minor", NULL
10788 };
10789
10790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10792 if (!SWIG_IsOK(res1)) {
10793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10794 }
10795 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10796 ecode2 = SWIG_AsVal_int(obj1, &val2);
10797 if (!SWIG_IsOK(ecode2)) {
10798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10799 }
10800 arg2 = static_cast< int >(val2);
10801 ecode3 = SWIG_AsVal_int(obj2, &val3);
10802 if (!SWIG_IsOK(ecode3)) {
10803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10804 }
10805 arg3 = static_cast< int >(val3);
10806 {
10807 PyThreadState* __tstate = wxPyBeginAllowThreads();
10808 (arg1)->SetOSVersion(arg2,arg3);
10809 wxPyEndAllowThreads(__tstate);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 resultobj = SWIG_Py_Void();
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = 0;
10821 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10822 int arg2 ;
10823 int arg3 ;
10824 void *argp1 = 0 ;
10825 int res1 = 0 ;
10826 int val2 ;
10827 int ecode2 = 0 ;
10828 int val3 ;
10829 int ecode3 = 0 ;
10830 PyObject * obj0 = 0 ;
10831 PyObject * obj1 = 0 ;
10832 PyObject * obj2 = 0 ;
10833 char * kwnames[] = {
10834 (char *) "self",(char *) "major",(char *) "minor", NULL
10835 };
10836
10837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10839 if (!SWIG_IsOK(res1)) {
10840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10841 }
10842 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10843 ecode2 = SWIG_AsVal_int(obj1, &val2);
10844 if (!SWIG_IsOK(ecode2)) {
10845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10846 }
10847 arg2 = static_cast< int >(val2);
10848 ecode3 = SWIG_AsVal_int(obj2, &val3);
10849 if (!SWIG_IsOK(ecode3)) {
10850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10851 }
10852 arg3 = static_cast< int >(val3);
10853 {
10854 PyThreadState* __tstate = wxPyBeginAllowThreads();
10855 (arg1)->SetToolkitVersion(arg2,arg3);
10856 wxPyEndAllowThreads(__tstate);
10857 if (PyErr_Occurred()) SWIG_fail;
10858 }
10859 resultobj = SWIG_Py_Void();
10860 return resultobj;
10861 fail:
10862 return NULL;
10863 }
10864
10865
10866 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10867 PyObject *resultobj = 0;
10868 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10869 wxOperatingSystemId arg2 ;
10870 void *argp1 = 0 ;
10871 int res1 = 0 ;
10872 int val2 ;
10873 int ecode2 = 0 ;
10874 PyObject * obj0 = 0 ;
10875 PyObject * obj1 = 0 ;
10876 char * kwnames[] = {
10877 (char *) "self",(char *) "n", NULL
10878 };
10879
10880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10882 if (!SWIG_IsOK(res1)) {
10883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10884 }
10885 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10886 ecode2 = SWIG_AsVal_int(obj1, &val2);
10887 if (!SWIG_IsOK(ecode2)) {
10888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10889 }
10890 arg2 = static_cast< wxOperatingSystemId >(val2);
10891 {
10892 PyThreadState* __tstate = wxPyBeginAllowThreads();
10893 (arg1)->SetOperatingSystemId(arg2);
10894 wxPyEndAllowThreads(__tstate);
10895 if (PyErr_Occurred()) SWIG_fail;
10896 }
10897 resultobj = SWIG_Py_Void();
10898 return resultobj;
10899 fail:
10900 return NULL;
10901 }
10902
10903
10904 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10905 PyObject *resultobj = 0;
10906 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10907 wxPortId arg2 ;
10908 void *argp1 = 0 ;
10909 int res1 = 0 ;
10910 int val2 ;
10911 int ecode2 = 0 ;
10912 PyObject * obj0 = 0 ;
10913 PyObject * obj1 = 0 ;
10914 char * kwnames[] = {
10915 (char *) "self",(char *) "n", NULL
10916 };
10917
10918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10920 if (!SWIG_IsOK(res1)) {
10921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10922 }
10923 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10924 ecode2 = SWIG_AsVal_int(obj1, &val2);
10925 if (!SWIG_IsOK(ecode2)) {
10926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10927 }
10928 arg2 = static_cast< wxPortId >(val2);
10929 {
10930 PyThreadState* __tstate = wxPyBeginAllowThreads();
10931 (arg1)->SetPortId(arg2);
10932 wxPyEndAllowThreads(__tstate);
10933 if (PyErr_Occurred()) SWIG_fail;
10934 }
10935 resultobj = SWIG_Py_Void();
10936 return resultobj;
10937 fail:
10938 return NULL;
10939 }
10940
10941
10942 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10943 PyObject *resultobj = 0;
10944 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10945 wxArchitecture arg2 ;
10946 void *argp1 = 0 ;
10947 int res1 = 0 ;
10948 int val2 ;
10949 int ecode2 = 0 ;
10950 PyObject * obj0 = 0 ;
10951 PyObject * obj1 = 0 ;
10952 char * kwnames[] = {
10953 (char *) "self",(char *) "n", NULL
10954 };
10955
10956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10958 if (!SWIG_IsOK(res1)) {
10959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10960 }
10961 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10962 ecode2 = SWIG_AsVal_int(obj1, &val2);
10963 if (!SWIG_IsOK(ecode2)) {
10964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
10965 }
10966 arg2 = static_cast< wxArchitecture >(val2);
10967 {
10968 PyThreadState* __tstate = wxPyBeginAllowThreads();
10969 (arg1)->SetArchitecture(arg2);
10970 wxPyEndAllowThreads(__tstate);
10971 if (PyErr_Occurred()) SWIG_fail;
10972 }
10973 resultobj = SWIG_Py_Void();
10974 return resultobj;
10975 fail:
10976 return NULL;
10977 }
10978
10979
10980 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10981 PyObject *resultobj = 0;
10982 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10983 wxEndianness arg2 ;
10984 void *argp1 = 0 ;
10985 int res1 = 0 ;
10986 int val2 ;
10987 int ecode2 = 0 ;
10988 PyObject * obj0 = 0 ;
10989 PyObject * obj1 = 0 ;
10990 char * kwnames[] = {
10991 (char *) "self",(char *) "n", NULL
10992 };
10993
10994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
10995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10996 if (!SWIG_IsOK(res1)) {
10997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10998 }
10999 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11000 ecode2 = SWIG_AsVal_int(obj1, &val2);
11001 if (!SWIG_IsOK(ecode2)) {
11002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11003 }
11004 arg2 = static_cast< wxEndianness >(val2);
11005 {
11006 PyThreadState* __tstate = wxPyBeginAllowThreads();
11007 (arg1)->SetEndianness(arg2);
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 resultobj = SWIG_Py_Void();
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 PyObject *resultobj = 0;
11020 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11021 bool result;
11022 void *argp1 = 0 ;
11023 int res1 = 0 ;
11024 PyObject *swig_obj[1] ;
11025
11026 if (!args) SWIG_fail;
11027 swig_obj[0] = args;
11028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11029 if (!SWIG_IsOK(res1)) {
11030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11031 }
11032 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11033 {
11034 PyThreadState* __tstate = wxPyBeginAllowThreads();
11035 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11036 wxPyEndAllowThreads(__tstate);
11037 if (PyErr_Occurred()) SWIG_fail;
11038 }
11039 {
11040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11041 }
11042 return resultobj;
11043 fail:
11044 return NULL;
11045 }
11046
11047
11048 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11049 PyObject *obj;
11050 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11051 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11052 return SWIG_Py_Void();
11053 }
11054
11055 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11056 return SWIG_Python_InitShadowInstance(args);
11057 }
11058
11059 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11060 PyObject *resultobj = 0;
11061 wxWindow *arg1 = (wxWindow *) 0 ;
11062 wxDC *arg2 = 0 ;
11063 bool result;
11064 void *argp1 = 0 ;
11065 int res1 = 0 ;
11066 void *argp2 = 0 ;
11067 int res2 = 0 ;
11068 PyObject * obj0 = 0 ;
11069 PyObject * obj1 = 0 ;
11070 char * kwnames[] = {
11071 (char *) "window",(char *) "dc", NULL
11072 };
11073
11074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11076 if (!SWIG_IsOK(res1)) {
11077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11078 }
11079 arg1 = reinterpret_cast< wxWindow * >(argp1);
11080 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11081 if (!SWIG_IsOK(res2)) {
11082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11083 }
11084 if (!argp2) {
11085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11086 }
11087 arg2 = reinterpret_cast< wxDC * >(argp2);
11088 {
11089 PyThreadState* __tstate = wxPyBeginAllowThreads();
11090 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11091 wxPyEndAllowThreads(__tstate);
11092 if (PyErr_Occurred()) SWIG_fail;
11093 }
11094 {
11095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11096 }
11097 return resultobj;
11098 fail:
11099 return NULL;
11100 }
11101
11102
11103 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11104 PyObject *resultobj = 0;
11105 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11106 void *argp1 = 0 ;
11107 int res1 = 0 ;
11108 PyObject *swig_obj[1] ;
11109
11110 if (!args) SWIG_fail;
11111 swig_obj[0] = args;
11112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11113 if (!SWIG_IsOK(res1)) {
11114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11115 }
11116 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11117 {
11118 PyThreadState* __tstate = wxPyBeginAllowThreads();
11119 delete arg1;
11120
11121 wxPyEndAllowThreads(__tstate);
11122 if (PyErr_Occurred()) SWIG_fail;
11123 }
11124 resultobj = SWIG_Py_Void();
11125 return resultobj;
11126 fail:
11127 return NULL;
11128 }
11129
11130
11131 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11132 PyObject *resultobj = 0;
11133 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11134 wxString result;
11135 void *argp1 = 0 ;
11136 int res1 = 0 ;
11137 PyObject *swig_obj[1] ;
11138
11139 if (!args) SWIG_fail;
11140 swig_obj[0] = args;
11141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11142 if (!SWIG_IsOK(res1)) {
11143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11144 }
11145 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11146 {
11147 PyThreadState* __tstate = wxPyBeginAllowThreads();
11148 result = (arg1)->GetTip();
11149 wxPyEndAllowThreads(__tstate);
11150 if (PyErr_Occurred()) SWIG_fail;
11151 }
11152 {
11153 #if wxUSE_UNICODE
11154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11155 #else
11156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11157 #endif
11158 }
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11166 PyObject *resultobj = 0;
11167 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11168 size_t result;
11169 void *argp1 = 0 ;
11170 int res1 = 0 ;
11171 PyObject *swig_obj[1] ;
11172
11173 if (!args) SWIG_fail;
11174 swig_obj[0] = args;
11175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11176 if (!SWIG_IsOK(res1)) {
11177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11178 }
11179 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11180 {
11181 PyThreadState* __tstate = wxPyBeginAllowThreads();
11182 result = (size_t)(arg1)->GetCurrentTip();
11183 wxPyEndAllowThreads(__tstate);
11184 if (PyErr_Occurred()) SWIG_fail;
11185 }
11186 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11187 return resultobj;
11188 fail:
11189 return NULL;
11190 }
11191
11192
11193 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11194 PyObject *resultobj = 0;
11195 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11196 wxString *arg2 = 0 ;
11197 wxString result;
11198 void *argp1 = 0 ;
11199 int res1 = 0 ;
11200 bool temp2 = false ;
11201 PyObject * obj0 = 0 ;
11202 PyObject * obj1 = 0 ;
11203 char * kwnames[] = {
11204 (char *) "self",(char *) "tip", NULL
11205 };
11206
11207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11209 if (!SWIG_IsOK(res1)) {
11210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11211 }
11212 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11213 {
11214 arg2 = wxString_in_helper(obj1);
11215 if (arg2 == NULL) SWIG_fail;
11216 temp2 = true;
11217 }
11218 {
11219 PyThreadState* __tstate = wxPyBeginAllowThreads();
11220 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 {
11225 #if wxUSE_UNICODE
11226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11227 #else
11228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11229 #endif
11230 }
11231 {
11232 if (temp2)
11233 delete arg2;
11234 }
11235 return resultobj;
11236 fail:
11237 {
11238 if (temp2)
11239 delete arg2;
11240 }
11241 return NULL;
11242 }
11243
11244
11245 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11246 PyObject *obj;
11247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11248 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11249 return SWIG_Py_Void();
11250 }
11251
11252 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11253 PyObject *resultobj = 0;
11254 size_t arg1 ;
11255 wxPyTipProvider *result = 0 ;
11256 size_t val1 ;
11257 int ecode1 = 0 ;
11258 PyObject * obj0 = 0 ;
11259 char * kwnames[] = {
11260 (char *) "currentTip", NULL
11261 };
11262
11263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11264 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11265 if (!SWIG_IsOK(ecode1)) {
11266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11267 }
11268 arg1 = static_cast< size_t >(val1);
11269 {
11270 PyThreadState* __tstate = wxPyBeginAllowThreads();
11271 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11272 wxPyEndAllowThreads(__tstate);
11273 if (PyErr_Occurred()) SWIG_fail;
11274 }
11275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11276 return resultobj;
11277 fail:
11278 return NULL;
11279 }
11280
11281
11282 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11283 PyObject *resultobj = 0;
11284 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11285 PyObject *arg2 = (PyObject *) 0 ;
11286 PyObject *arg3 = (PyObject *) 0 ;
11287 void *argp1 = 0 ;
11288 int res1 = 0 ;
11289 PyObject * obj0 = 0 ;
11290 PyObject * obj1 = 0 ;
11291 PyObject * obj2 = 0 ;
11292 char * kwnames[] = {
11293 (char *) "self",(char *) "self",(char *) "_class", NULL
11294 };
11295
11296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11298 if (!SWIG_IsOK(res1)) {
11299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11300 }
11301 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11302 arg2 = obj1;
11303 arg3 = obj2;
11304 {
11305 PyThreadState* __tstate = wxPyBeginAllowThreads();
11306 (arg1)->_setCallbackInfo(arg2,arg3);
11307 wxPyEndAllowThreads(__tstate);
11308 if (PyErr_Occurred()) SWIG_fail;
11309 }
11310 resultobj = SWIG_Py_Void();
11311 return resultobj;
11312 fail:
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11318 PyObject *obj;
11319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11320 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11321 return SWIG_Py_Void();
11322 }
11323
11324 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11325 return SWIG_Python_InitShadowInstance(args);
11326 }
11327
11328 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11329 PyObject *resultobj = 0;
11330 wxWindow *arg1 = (wxWindow *) 0 ;
11331 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11332 bool arg3 = (bool) true ;
11333 bool result;
11334 void *argp1 = 0 ;
11335 int res1 = 0 ;
11336 void *argp2 = 0 ;
11337 int res2 = 0 ;
11338 bool val3 ;
11339 int ecode3 = 0 ;
11340 PyObject * obj0 = 0 ;
11341 PyObject * obj1 = 0 ;
11342 PyObject * obj2 = 0 ;
11343 char * kwnames[] = {
11344 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11345 };
11346
11347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11349 if (!SWIG_IsOK(res1)) {
11350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11351 }
11352 arg1 = reinterpret_cast< wxWindow * >(argp1);
11353 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11354 if (!SWIG_IsOK(res2)) {
11355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11356 }
11357 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11358 if (obj2) {
11359 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11360 if (!SWIG_IsOK(ecode3)) {
11361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11362 }
11363 arg3 = static_cast< bool >(val3);
11364 }
11365 {
11366 if (!wxPyCheckForApp()) SWIG_fail;
11367 PyThreadState* __tstate = wxPyBeginAllowThreads();
11368 result = (bool)wxShowTip(arg1,arg2,arg3);
11369 wxPyEndAllowThreads(__tstate);
11370 if (PyErr_Occurred()) SWIG_fail;
11371 }
11372 {
11373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11374 }
11375 return resultobj;
11376 fail:
11377 return NULL;
11378 }
11379
11380
11381 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11382 PyObject *resultobj = 0;
11383 wxString *arg1 = 0 ;
11384 size_t arg2 ;
11385 wxTipProvider *result = 0 ;
11386 bool temp1 = false ;
11387 size_t val2 ;
11388 int ecode2 = 0 ;
11389 PyObject * obj0 = 0 ;
11390 PyObject * obj1 = 0 ;
11391 char * kwnames[] = {
11392 (char *) "filename",(char *) "currentTip", NULL
11393 };
11394
11395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11396 {
11397 arg1 = wxString_in_helper(obj0);
11398 if (arg1 == NULL) SWIG_fail;
11399 temp1 = true;
11400 }
11401 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11402 if (!SWIG_IsOK(ecode2)) {
11403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11404 }
11405 arg2 = static_cast< size_t >(val2);
11406 {
11407 if (!wxPyCheckForApp()) SWIG_fail;
11408 PyThreadState* __tstate = wxPyBeginAllowThreads();
11409 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11410 wxPyEndAllowThreads(__tstate);
11411 if (PyErr_Occurred()) SWIG_fail;
11412 }
11413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11414 {
11415 if (temp1)
11416 delete arg1;
11417 }
11418 return resultobj;
11419 fail:
11420 {
11421 if (temp1)
11422 delete arg1;
11423 }
11424 return NULL;
11425 }
11426
11427
11428 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11429 PyObject *resultobj = 0;
11430 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11431 int arg2 = (int) wxID_ANY ;
11432 wxPyTimer *result = 0 ;
11433 void *argp1 = 0 ;
11434 int res1 = 0 ;
11435 int val2 ;
11436 int ecode2 = 0 ;
11437 PyObject * obj0 = 0 ;
11438 PyObject * obj1 = 0 ;
11439 char * kwnames[] = {
11440 (char *) "owner",(char *) "id", NULL
11441 };
11442
11443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11444 if (obj0) {
11445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11446 if (!SWIG_IsOK(res1)) {
11447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11448 }
11449 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11450 }
11451 if (obj1) {
11452 ecode2 = SWIG_AsVal_int(obj1, &val2);
11453 if (!SWIG_IsOK(ecode2)) {
11454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11455 }
11456 arg2 = static_cast< int >(val2);
11457 }
11458 {
11459 if (!wxPyCheckForApp()) SWIG_fail;
11460 PyThreadState* __tstate = wxPyBeginAllowThreads();
11461 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11462 wxPyEndAllowThreads(__tstate);
11463 if (PyErr_Occurred()) SWIG_fail;
11464 }
11465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11466 return resultobj;
11467 fail:
11468 return NULL;
11469 }
11470
11471
11472 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11473 PyObject *resultobj = 0;
11474 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11475 void *argp1 = 0 ;
11476 int res1 = 0 ;
11477 PyObject *swig_obj[1] ;
11478
11479 if (!args) SWIG_fail;
11480 swig_obj[0] = args;
11481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11482 if (!SWIG_IsOK(res1)) {
11483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11484 }
11485 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11486 {
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 delete arg1;
11489
11490 wxPyEndAllowThreads(__tstate);
11491 if (PyErr_Occurred()) SWIG_fail;
11492 }
11493 resultobj = SWIG_Py_Void();
11494 return resultobj;
11495 fail:
11496 return NULL;
11497 }
11498
11499
11500 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11501 PyObject *resultobj = 0;
11502 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11503 PyObject *arg2 = (PyObject *) 0 ;
11504 PyObject *arg3 = (PyObject *) 0 ;
11505 int arg4 = (int) 1 ;
11506 void *argp1 = 0 ;
11507 int res1 = 0 ;
11508 int val4 ;
11509 int ecode4 = 0 ;
11510 PyObject * obj0 = 0 ;
11511 PyObject * obj1 = 0 ;
11512 PyObject * obj2 = 0 ;
11513 PyObject * obj3 = 0 ;
11514 char * kwnames[] = {
11515 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11516 };
11517
11518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11520 if (!SWIG_IsOK(res1)) {
11521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11522 }
11523 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11524 arg2 = obj1;
11525 arg3 = obj2;
11526 if (obj3) {
11527 ecode4 = SWIG_AsVal_int(obj3, &val4);
11528 if (!SWIG_IsOK(ecode4)) {
11529 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11530 }
11531 arg4 = static_cast< int >(val4);
11532 }
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11536 wxPyEndAllowThreads(__tstate);
11537 if (PyErr_Occurred()) SWIG_fail;
11538 }
11539 resultobj = SWIG_Py_Void();
11540 return resultobj;
11541 fail:
11542 return NULL;
11543 }
11544
11545
11546 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11547 PyObject *resultobj = 0;
11548 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11549 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11550 int arg3 = (int) wxID_ANY ;
11551 void *argp1 = 0 ;
11552 int res1 = 0 ;
11553 void *argp2 = 0 ;
11554 int res2 = 0 ;
11555 int val3 ;
11556 int ecode3 = 0 ;
11557 PyObject * obj0 = 0 ;
11558 PyObject * obj1 = 0 ;
11559 PyObject * obj2 = 0 ;
11560 char * kwnames[] = {
11561 (char *) "self",(char *) "owner",(char *) "id", NULL
11562 };
11563
11564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11566 if (!SWIG_IsOK(res1)) {
11567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11568 }
11569 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11571 if (!SWIG_IsOK(res2)) {
11572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11573 }
11574 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11575 if (obj2) {
11576 ecode3 = SWIG_AsVal_int(obj2, &val3);
11577 if (!SWIG_IsOK(ecode3)) {
11578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11579 }
11580 arg3 = static_cast< int >(val3);
11581 }
11582 {
11583 PyThreadState* __tstate = wxPyBeginAllowThreads();
11584 (arg1)->SetOwner(arg2,arg3);
11585 wxPyEndAllowThreads(__tstate);
11586 if (PyErr_Occurred()) SWIG_fail;
11587 }
11588 resultobj = SWIG_Py_Void();
11589 return resultobj;
11590 fail:
11591 return NULL;
11592 }
11593
11594
11595 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11596 PyObject *resultobj = 0;
11597 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11598 wxEvtHandler *result = 0 ;
11599 void *argp1 = 0 ;
11600 int res1 = 0 ;
11601 PyObject *swig_obj[1] ;
11602
11603 if (!args) SWIG_fail;
11604 swig_obj[0] = args;
11605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11606 if (!SWIG_IsOK(res1)) {
11607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11608 }
11609 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 result = (wxEvtHandler *)(arg1)->GetOwner();
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 {
11617 resultobj = wxPyMake_wxObject(result, 0);
11618 }
11619 return resultobj;
11620 fail:
11621 return NULL;
11622 }
11623
11624
11625 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11626 PyObject *resultobj = 0;
11627 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11628 int arg2 = (int) -1 ;
11629 bool arg3 = (bool) false ;
11630 bool result;
11631 void *argp1 = 0 ;
11632 int res1 = 0 ;
11633 int val2 ;
11634 int ecode2 = 0 ;
11635 bool val3 ;
11636 int ecode3 = 0 ;
11637 PyObject * obj0 = 0 ;
11638 PyObject * obj1 = 0 ;
11639 PyObject * obj2 = 0 ;
11640 char * kwnames[] = {
11641 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11642 };
11643
11644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11646 if (!SWIG_IsOK(res1)) {
11647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11648 }
11649 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11650 if (obj1) {
11651 ecode2 = SWIG_AsVal_int(obj1, &val2);
11652 if (!SWIG_IsOK(ecode2)) {
11653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11654 }
11655 arg2 = static_cast< int >(val2);
11656 }
11657 if (obj2) {
11658 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11659 if (!SWIG_IsOK(ecode3)) {
11660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11661 }
11662 arg3 = static_cast< bool >(val3);
11663 }
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 result = (bool)(arg1)->Start(arg2,arg3);
11667 wxPyEndAllowThreads(__tstate);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 {
11671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11672 }
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11680 PyObject *resultobj = 0;
11681 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11682 void *argp1 = 0 ;
11683 int res1 = 0 ;
11684 PyObject *swig_obj[1] ;
11685
11686 if (!args) SWIG_fail;
11687 swig_obj[0] = args;
11688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11689 if (!SWIG_IsOK(res1)) {
11690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11691 }
11692 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11693 {
11694 PyThreadState* __tstate = wxPyBeginAllowThreads();
11695 (arg1)->Stop();
11696 wxPyEndAllowThreads(__tstate);
11697 if (PyErr_Occurred()) SWIG_fail;
11698 }
11699 resultobj = SWIG_Py_Void();
11700 return resultobj;
11701 fail:
11702 return NULL;
11703 }
11704
11705
11706 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11707 PyObject *resultobj = 0;
11708 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11709 void *argp1 = 0 ;
11710 int res1 = 0 ;
11711 PyObject *swig_obj[1] ;
11712
11713 if (!args) SWIG_fail;
11714 swig_obj[0] = args;
11715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11716 if (!SWIG_IsOK(res1)) {
11717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11718 }
11719 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11720 {
11721 PyThreadState* __tstate = wxPyBeginAllowThreads();
11722 (arg1)->Notify();
11723 wxPyEndAllowThreads(__tstate);
11724 if (PyErr_Occurred()) SWIG_fail;
11725 }
11726 resultobj = SWIG_Py_Void();
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11734 PyObject *resultobj = 0;
11735 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11736 bool result;
11737 void *argp1 = 0 ;
11738 int res1 = 0 ;
11739 PyObject *swig_obj[1] ;
11740
11741 if (!args) SWIG_fail;
11742 swig_obj[0] = args;
11743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11744 if (!SWIG_IsOK(res1)) {
11745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11746 }
11747 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11748 {
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 {
11755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11756 }
11757 return resultobj;
11758 fail:
11759 return NULL;
11760 }
11761
11762
11763 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11764 PyObject *resultobj = 0;
11765 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11766 int result;
11767 void *argp1 = 0 ;
11768 int res1 = 0 ;
11769 PyObject *swig_obj[1] ;
11770
11771 if (!args) SWIG_fail;
11772 swig_obj[0] = args;
11773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11774 if (!SWIG_IsOK(res1)) {
11775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11776 }
11777 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11778 {
11779 PyThreadState* __tstate = wxPyBeginAllowThreads();
11780 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11781 wxPyEndAllowThreads(__tstate);
11782 if (PyErr_Occurred()) SWIG_fail;
11783 }
11784 resultobj = SWIG_From_int(static_cast< int >(result));
11785 return resultobj;
11786 fail:
11787 return NULL;
11788 }
11789
11790
11791 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11792 PyObject *resultobj = 0;
11793 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11794 int result;
11795 void *argp1 = 0 ;
11796 int res1 = 0 ;
11797 PyObject *swig_obj[1] ;
11798
11799 if (!args) SWIG_fail;
11800 swig_obj[0] = args;
11801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11802 if (!SWIG_IsOK(res1)) {
11803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11804 }
11805 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11806 {
11807 PyThreadState* __tstate = wxPyBeginAllowThreads();
11808 result = (int)((wxPyTimer const *)arg1)->GetId();
11809 wxPyEndAllowThreads(__tstate);
11810 if (PyErr_Occurred()) SWIG_fail;
11811 }
11812 resultobj = SWIG_From_int(static_cast< int >(result));
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11820 PyObject *resultobj = 0;
11821 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11822 bool result;
11823 void *argp1 = 0 ;
11824 int res1 = 0 ;
11825 PyObject *swig_obj[1] ;
11826
11827 if (!args) SWIG_fail;
11828 swig_obj[0] = args;
11829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11830 if (!SWIG_IsOK(res1)) {
11831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11832 }
11833 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 {
11841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11842 }
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *obj;
11851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11852 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11853 return SWIG_Py_Void();
11854 }
11855
11856 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11857 return SWIG_Python_InitShadowInstance(args);
11858 }
11859
11860 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11861 PyObject *resultobj = 0;
11862 int arg1 = (int) 0 ;
11863 int arg2 = (int) 0 ;
11864 wxTimerEvent *result = 0 ;
11865 int val1 ;
11866 int ecode1 = 0 ;
11867 int val2 ;
11868 int ecode2 = 0 ;
11869 PyObject * obj0 = 0 ;
11870 PyObject * obj1 = 0 ;
11871 char * kwnames[] = {
11872 (char *) "timerid",(char *) "interval", NULL
11873 };
11874
11875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11876 if (obj0) {
11877 ecode1 = SWIG_AsVal_int(obj0, &val1);
11878 if (!SWIG_IsOK(ecode1)) {
11879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11880 }
11881 arg1 = static_cast< int >(val1);
11882 }
11883 if (obj1) {
11884 ecode2 = SWIG_AsVal_int(obj1, &val2);
11885 if (!SWIG_IsOK(ecode2)) {
11886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11887 }
11888 arg2 = static_cast< int >(val2);
11889 }
11890 {
11891 PyThreadState* __tstate = wxPyBeginAllowThreads();
11892 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11893 wxPyEndAllowThreads(__tstate);
11894 if (PyErr_Occurred()) SWIG_fail;
11895 }
11896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11897 return resultobj;
11898 fail:
11899 return NULL;
11900 }
11901
11902
11903 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11904 PyObject *resultobj = 0;
11905 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11906 int result;
11907 void *argp1 = 0 ;
11908 int res1 = 0 ;
11909 PyObject *swig_obj[1] ;
11910
11911 if (!args) SWIG_fail;
11912 swig_obj[0] = args;
11913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11914 if (!SWIG_IsOK(res1)) {
11915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11916 }
11917 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11918 {
11919 PyThreadState* __tstate = wxPyBeginAllowThreads();
11920 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11921 wxPyEndAllowThreads(__tstate);
11922 if (PyErr_Occurred()) SWIG_fail;
11923 }
11924 resultobj = SWIG_From_int(static_cast< int >(result));
11925 return resultobj;
11926 fail:
11927 return NULL;
11928 }
11929
11930
11931 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11932 PyObject *obj;
11933 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11934 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11935 return SWIG_Py_Void();
11936 }
11937
11938 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11939 return SWIG_Python_InitShadowInstance(args);
11940 }
11941
11942 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11943 PyObject *resultobj = 0;
11944 wxTimer *arg1 = 0 ;
11945 wxTimerRunner *result = 0 ;
11946 void *argp1 = 0 ;
11947 int res1 = 0 ;
11948
11949 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11951 if (!SWIG_IsOK(res1)) {
11952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11953 }
11954 if (!argp1) {
11955 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11956 }
11957 arg1 = reinterpret_cast< wxTimer * >(argp1);
11958 {
11959 if (!wxPyCheckForApp()) SWIG_fail;
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
11962 wxPyEndAllowThreads(__tstate);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
11966 return resultobj;
11967 fail:
11968 return NULL;
11969 }
11970
11971
11972 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11973 PyObject *resultobj = 0;
11974 wxTimer *arg1 = 0 ;
11975 int arg2 ;
11976 bool arg3 = (bool) false ;
11977 wxTimerRunner *result = 0 ;
11978 void *argp1 = 0 ;
11979 int res1 = 0 ;
11980 int val2 ;
11981 int ecode2 = 0 ;
11982 bool val3 ;
11983 int ecode3 = 0 ;
11984
11985 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
11986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11987 if (!SWIG_IsOK(res1)) {
11988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11989 }
11990 if (!argp1) {
11991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11992 }
11993 arg1 = reinterpret_cast< wxTimer * >(argp1);
11994 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11995 if (!SWIG_IsOK(ecode2)) {
11996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
11997 }
11998 arg2 = static_cast< int >(val2);
11999 if (swig_obj[2]) {
12000 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12001 if (!SWIG_IsOK(ecode3)) {
12002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12003 }
12004 arg3 = static_cast< bool >(val3);
12005 }
12006 {
12007 if (!wxPyCheckForApp()) SWIG_fail;
12008 PyThreadState* __tstate = wxPyBeginAllowThreads();
12009 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12010 wxPyEndAllowThreads(__tstate);
12011 if (PyErr_Occurred()) SWIG_fail;
12012 }
12013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12014 return resultobj;
12015 fail:
12016 return NULL;
12017 }
12018
12019
12020 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12021 int argc;
12022 PyObject *argv[4];
12023
12024 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12025 --argc;
12026 if (argc == 1) {
12027 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12028 }
12029 if ((argc >= 2) && (argc <= 3)) {
12030 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12031 }
12032
12033 fail:
12034 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12035 return NULL;
12036 }
12037
12038
12039 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12040 PyObject *resultobj = 0;
12041 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12042 void *argp1 = 0 ;
12043 int res1 = 0 ;
12044 PyObject *swig_obj[1] ;
12045
12046 if (!args) SWIG_fail;
12047 swig_obj[0] = args;
12048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12049 if (!SWIG_IsOK(res1)) {
12050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12051 }
12052 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12053 {
12054 PyThreadState* __tstate = wxPyBeginAllowThreads();
12055 delete arg1;
12056
12057 wxPyEndAllowThreads(__tstate);
12058 if (PyErr_Occurred()) SWIG_fail;
12059 }
12060 resultobj = SWIG_Py_Void();
12061 return resultobj;
12062 fail:
12063 return NULL;
12064 }
12065
12066
12067 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12068 PyObject *resultobj = 0;
12069 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12070 int arg2 ;
12071 bool arg3 = (bool) false ;
12072 void *argp1 = 0 ;
12073 int res1 = 0 ;
12074 int val2 ;
12075 int ecode2 = 0 ;
12076 bool val3 ;
12077 int ecode3 = 0 ;
12078 PyObject * obj0 = 0 ;
12079 PyObject * obj1 = 0 ;
12080 PyObject * obj2 = 0 ;
12081 char * kwnames[] = {
12082 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12083 };
12084
12085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12087 if (!SWIG_IsOK(res1)) {
12088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12089 }
12090 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12091 ecode2 = SWIG_AsVal_int(obj1, &val2);
12092 if (!SWIG_IsOK(ecode2)) {
12093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12094 }
12095 arg2 = static_cast< int >(val2);
12096 if (obj2) {
12097 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12098 if (!SWIG_IsOK(ecode3)) {
12099 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12100 }
12101 arg3 = static_cast< bool >(val3);
12102 }
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 (arg1)->Start(arg2,arg3);
12106 wxPyEndAllowThreads(__tstate);
12107 if (PyErr_Occurred()) SWIG_fail;
12108 }
12109 resultobj = SWIG_Py_Void();
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12117 PyObject *obj;
12118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12119 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12120 return SWIG_Py_Void();
12121 }
12122
12123 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12124 return SWIG_Python_InitShadowInstance(args);
12125 }
12126
12127 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12128 PyObject *resultobj = 0;
12129 wxLog *result = 0 ;
12130
12131 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12132 {
12133 PyThreadState* __tstate = wxPyBeginAllowThreads();
12134 result = (wxLog *)new wxLog();
12135 wxPyEndAllowThreads(__tstate);
12136 if (PyErr_Occurred()) SWIG_fail;
12137 }
12138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12139 return resultobj;
12140 fail:
12141 return NULL;
12142 }
12143
12144
12145 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12146 PyObject *resultobj = 0;
12147 wxLog *arg1 = (wxLog *) 0 ;
12148 void *argp1 = 0 ;
12149 int res1 = 0 ;
12150 PyObject *swig_obj[1] ;
12151
12152 if (!args) SWIG_fail;
12153 swig_obj[0] = args;
12154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12155 if (!SWIG_IsOK(res1)) {
12156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12157 }
12158 arg1 = reinterpret_cast< wxLog * >(argp1);
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 delete arg1;
12162
12163 wxPyEndAllowThreads(__tstate);
12164 if (PyErr_Occurred()) SWIG_fail;
12165 }
12166 resultobj = SWIG_Py_Void();
12167 return resultobj;
12168 fail:
12169 return NULL;
12170 }
12171
12172
12173 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12174 PyObject *resultobj = 0;
12175 bool result;
12176
12177 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12178 {
12179 PyThreadState* __tstate = wxPyBeginAllowThreads();
12180 result = (bool)wxLog::IsEnabled();
12181 wxPyEndAllowThreads(__tstate);
12182 if (PyErr_Occurred()) SWIG_fail;
12183 }
12184 {
12185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12186 }
12187 return resultobj;
12188 fail:
12189 return NULL;
12190 }
12191
12192
12193 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12194 PyObject *resultobj = 0;
12195 bool arg1 = (bool) true ;
12196 bool result;
12197 bool val1 ;
12198 int ecode1 = 0 ;
12199 PyObject * obj0 = 0 ;
12200 char * kwnames[] = {
12201 (char *) "doIt", NULL
12202 };
12203
12204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12205 if (obj0) {
12206 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12207 if (!SWIG_IsOK(ecode1)) {
12208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12209 }
12210 arg1 = static_cast< bool >(val1);
12211 }
12212 {
12213 PyThreadState* __tstate = wxPyBeginAllowThreads();
12214 result = (bool)wxLog::EnableLogging(arg1);
12215 wxPyEndAllowThreads(__tstate);
12216 if (PyErr_Occurred()) SWIG_fail;
12217 }
12218 {
12219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12220 }
12221 return resultobj;
12222 fail:
12223 return NULL;
12224 }
12225
12226
12227 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12228 PyObject *resultobj = 0;
12229 wxLogLevel arg1 ;
12230 wxChar *arg2 = (wxChar *) 0 ;
12231 time_t arg3 ;
12232 unsigned long val1 ;
12233 int ecode1 = 0 ;
12234 void *argp2 = 0 ;
12235 int res2 = 0 ;
12236 unsigned int val3 ;
12237 int ecode3 = 0 ;
12238 PyObject * obj0 = 0 ;
12239 PyObject * obj1 = 0 ;
12240 PyObject * obj2 = 0 ;
12241 char * kwnames[] = {
12242 (char *) "level",(char *) "szString",(char *) "t", NULL
12243 };
12244
12245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12246 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12247 if (!SWIG_IsOK(ecode1)) {
12248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12249 }
12250 arg1 = static_cast< wxLogLevel >(val1);
12251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12252 if (!SWIG_IsOK(res2)) {
12253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12254 }
12255 arg2 = reinterpret_cast< wxChar * >(argp2);
12256 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12257 if (!SWIG_IsOK(ecode3)) {
12258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12259 }
12260 arg3 = static_cast< time_t >(val3);
12261 {
12262 PyThreadState* __tstate = wxPyBeginAllowThreads();
12263 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12264 wxPyEndAllowThreads(__tstate);
12265 if (PyErr_Occurred()) SWIG_fail;
12266 }
12267 resultobj = SWIG_Py_Void();
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12275 PyObject *resultobj = 0;
12276 wxLog *arg1 = (wxLog *) 0 ;
12277 void *argp1 = 0 ;
12278 int res1 = 0 ;
12279 PyObject *swig_obj[1] ;
12280
12281 if (!args) SWIG_fail;
12282 swig_obj[0] = args;
12283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12284 if (!SWIG_IsOK(res1)) {
12285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12286 }
12287 arg1 = reinterpret_cast< wxLog * >(argp1);
12288 {
12289 PyThreadState* __tstate = wxPyBeginAllowThreads();
12290 (arg1)->Flush();
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 resultobj = SWIG_Py_Void();
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12302 PyObject *resultobj = 0;
12303
12304 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12305 {
12306 PyThreadState* __tstate = wxPyBeginAllowThreads();
12307 wxLog::FlushActive();
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 resultobj = SWIG_Py_Void();
12312 return resultobj;
12313 fail:
12314 return NULL;
12315 }
12316
12317
12318 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12319 PyObject *resultobj = 0;
12320 wxLog *result = 0 ;
12321
12322 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 result = (wxLog *)wxLog::GetActiveTarget();
12326 wxPyEndAllowThreads(__tstate);
12327 if (PyErr_Occurred()) SWIG_fail;
12328 }
12329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12330 return resultobj;
12331 fail:
12332 return NULL;
12333 }
12334
12335
12336 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12337 PyObject *resultobj = 0;
12338 wxLog *arg1 = (wxLog *) 0 ;
12339 wxLog *result = 0 ;
12340 int res1 = 0 ;
12341 PyObject * obj0 = 0 ;
12342 char * kwnames[] = {
12343 (char *) "pLogger", NULL
12344 };
12345
12346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12347 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12348 if (!SWIG_IsOK(res1)) {
12349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12350 }
12351 {
12352 PyThreadState* __tstate = wxPyBeginAllowThreads();
12353 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12354 wxPyEndAllowThreads(__tstate);
12355 if (PyErr_Occurred()) SWIG_fail;
12356 }
12357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12358 return resultobj;
12359 fail:
12360 return NULL;
12361 }
12362
12363
12364 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12365 PyObject *resultobj = 0;
12366
12367 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12368 {
12369 PyThreadState* __tstate = wxPyBeginAllowThreads();
12370 wxLog::Suspend();
12371 wxPyEndAllowThreads(__tstate);
12372 if (PyErr_Occurred()) SWIG_fail;
12373 }
12374 resultobj = SWIG_Py_Void();
12375 return resultobj;
12376 fail:
12377 return NULL;
12378 }
12379
12380
12381 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12382 PyObject *resultobj = 0;
12383
12384 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12385 {
12386 PyThreadState* __tstate = wxPyBeginAllowThreads();
12387 wxLog::Resume();
12388 wxPyEndAllowThreads(__tstate);
12389 if (PyErr_Occurred()) SWIG_fail;
12390 }
12391 resultobj = SWIG_Py_Void();
12392 return resultobj;
12393 fail:
12394 return NULL;
12395 }
12396
12397
12398 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12399 PyObject *resultobj = 0;
12400 bool arg1 = (bool) true ;
12401 bool val1 ;
12402 int ecode1 = 0 ;
12403 PyObject * obj0 = 0 ;
12404 char * kwnames[] = {
12405 (char *) "bVerbose", NULL
12406 };
12407
12408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12409 if (obj0) {
12410 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12411 if (!SWIG_IsOK(ecode1)) {
12412 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12413 }
12414 arg1 = static_cast< bool >(val1);
12415 }
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 wxLog::SetVerbose(arg1);
12419 wxPyEndAllowThreads(__tstate);
12420 if (PyErr_Occurred()) SWIG_fail;
12421 }
12422 resultobj = SWIG_Py_Void();
12423 return resultobj;
12424 fail:
12425 return NULL;
12426 }
12427
12428
12429 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12430 PyObject *resultobj = 0;
12431 wxLogLevel arg1 ;
12432 unsigned long val1 ;
12433 int ecode1 = 0 ;
12434 PyObject * obj0 = 0 ;
12435 char * kwnames[] = {
12436 (char *) "logLevel", NULL
12437 };
12438
12439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12440 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12441 if (!SWIG_IsOK(ecode1)) {
12442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12443 }
12444 arg1 = static_cast< wxLogLevel >(val1);
12445 {
12446 PyThreadState* __tstate = wxPyBeginAllowThreads();
12447 wxLog::SetLogLevel(arg1);
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 resultobj = SWIG_Py_Void();
12452 return resultobj;
12453 fail:
12454 return NULL;
12455 }
12456
12457
12458 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12459 PyObject *resultobj = 0;
12460
12461 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12462 {
12463 PyThreadState* __tstate = wxPyBeginAllowThreads();
12464 wxLog::DontCreateOnDemand();
12465 wxPyEndAllowThreads(__tstate);
12466 if (PyErr_Occurred()) SWIG_fail;
12467 }
12468 resultobj = SWIG_Py_Void();
12469 return resultobj;
12470 fail:
12471 return NULL;
12472 }
12473
12474
12475 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12476 PyObject *resultobj = 0;
12477 bool arg1 = (bool) true ;
12478 bool val1 ;
12479 int ecode1 = 0 ;
12480 PyObject * obj0 = 0 ;
12481 char * kwnames[] = {
12482 (char *) "bRepetCounting", NULL
12483 };
12484
12485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12486 if (obj0) {
12487 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12488 if (!SWIG_IsOK(ecode1)) {
12489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12490 }
12491 arg1 = static_cast< bool >(val1);
12492 }
12493 {
12494 PyThreadState* __tstate = wxPyBeginAllowThreads();
12495 wxLog::SetRepetitionCounting(arg1);
12496 wxPyEndAllowThreads(__tstate);
12497 if (PyErr_Occurred()) SWIG_fail;
12498 }
12499 resultobj = SWIG_Py_Void();
12500 return resultobj;
12501 fail:
12502 return NULL;
12503 }
12504
12505
12506 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12507 PyObject *resultobj = 0;
12508 bool result;
12509
12510 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12511 {
12512 PyThreadState* __tstate = wxPyBeginAllowThreads();
12513 result = (bool)wxLog::GetRepetitionCounting();
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 {
12518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12519 }
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12527 PyObject *resultobj = 0;
12528 wxTraceMask arg1 ;
12529 unsigned long val1 ;
12530 int ecode1 = 0 ;
12531 PyObject * obj0 = 0 ;
12532 char * kwnames[] = {
12533 (char *) "ulMask", NULL
12534 };
12535
12536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12537 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12538 if (!SWIG_IsOK(ecode1)) {
12539 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12540 }
12541 arg1 = static_cast< wxTraceMask >(val1);
12542 {
12543 PyThreadState* __tstate = wxPyBeginAllowThreads();
12544 wxLog::SetTraceMask(arg1);
12545 wxPyEndAllowThreads(__tstate);
12546 if (PyErr_Occurred()) SWIG_fail;
12547 }
12548 resultobj = SWIG_Py_Void();
12549 return resultobj;
12550 fail:
12551 return NULL;
12552 }
12553
12554
12555 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12556 PyObject *resultobj = 0;
12557 wxString *arg1 = 0 ;
12558 bool temp1 = false ;
12559 PyObject * obj0 = 0 ;
12560 char * kwnames[] = {
12561 (char *) "str", NULL
12562 };
12563
12564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12565 {
12566 arg1 = wxString_in_helper(obj0);
12567 if (arg1 == NULL) SWIG_fail;
12568 temp1 = true;
12569 }
12570 {
12571 PyThreadState* __tstate = wxPyBeginAllowThreads();
12572 wxLog::AddTraceMask((wxString const &)*arg1);
12573 wxPyEndAllowThreads(__tstate);
12574 if (PyErr_Occurred()) SWIG_fail;
12575 }
12576 resultobj = SWIG_Py_Void();
12577 {
12578 if (temp1)
12579 delete arg1;
12580 }
12581 return resultobj;
12582 fail:
12583 {
12584 if (temp1)
12585 delete arg1;
12586 }
12587 return NULL;
12588 }
12589
12590
12591 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12592 PyObject *resultobj = 0;
12593 wxString *arg1 = 0 ;
12594 bool temp1 = false ;
12595 PyObject * obj0 = 0 ;
12596 char * kwnames[] = {
12597 (char *) "str", NULL
12598 };
12599
12600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12601 {
12602 arg1 = wxString_in_helper(obj0);
12603 if (arg1 == NULL) SWIG_fail;
12604 temp1 = true;
12605 }
12606 {
12607 PyThreadState* __tstate = wxPyBeginAllowThreads();
12608 wxLog::RemoveTraceMask((wxString const &)*arg1);
12609 wxPyEndAllowThreads(__tstate);
12610 if (PyErr_Occurred()) SWIG_fail;
12611 }
12612 resultobj = SWIG_Py_Void();
12613 {
12614 if (temp1)
12615 delete arg1;
12616 }
12617 return resultobj;
12618 fail:
12619 {
12620 if (temp1)
12621 delete arg1;
12622 }
12623 return NULL;
12624 }
12625
12626
12627 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12628 PyObject *resultobj = 0;
12629
12630 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 wxLog::ClearTraceMasks();
12634 wxPyEndAllowThreads(__tstate);
12635 if (PyErr_Occurred()) SWIG_fail;
12636 }
12637 resultobj = SWIG_Py_Void();
12638 return resultobj;
12639 fail:
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12645 PyObject *resultobj = 0;
12646 wxArrayString *result = 0 ;
12647
12648 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12649 {
12650 PyThreadState* __tstate = wxPyBeginAllowThreads();
12651 {
12652 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12653 result = (wxArrayString *) &_result_ref;
12654 }
12655 wxPyEndAllowThreads(__tstate);
12656 if (PyErr_Occurred()) SWIG_fail;
12657 }
12658 {
12659 resultobj = wxArrayString2PyList_helper(*result);
12660 }
12661 return resultobj;
12662 fail:
12663 return NULL;
12664 }
12665
12666
12667 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12668 PyObject *resultobj = 0;
12669 wxChar *arg1 = (wxChar *) 0 ;
12670 void *argp1 = 0 ;
12671 int res1 = 0 ;
12672 PyObject * obj0 = 0 ;
12673 char * kwnames[] = {
12674 (char *) "ts", NULL
12675 };
12676
12677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12679 if (!SWIG_IsOK(res1)) {
12680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12681 }
12682 arg1 = reinterpret_cast< wxChar * >(argp1);
12683 {
12684 PyThreadState* __tstate = wxPyBeginAllowThreads();
12685 wxLog::SetTimestamp((wxChar const *)arg1);
12686 wxPyEndAllowThreads(__tstate);
12687 if (PyErr_Occurred()) SWIG_fail;
12688 }
12689 resultobj = SWIG_Py_Void();
12690 return resultobj;
12691 fail:
12692 return NULL;
12693 }
12694
12695
12696 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12697 PyObject *resultobj = 0;
12698 bool result;
12699
12700 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12701 {
12702 PyThreadState* __tstate = wxPyBeginAllowThreads();
12703 result = (bool)wxLog::GetVerbose();
12704 wxPyEndAllowThreads(__tstate);
12705 if (PyErr_Occurred()) SWIG_fail;
12706 }
12707 {
12708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12709 }
12710 return resultobj;
12711 fail:
12712 return NULL;
12713 }
12714
12715
12716 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12717 PyObject *resultobj = 0;
12718 wxTraceMask result;
12719
12720 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12721 {
12722 PyThreadState* __tstate = wxPyBeginAllowThreads();
12723 result = (wxTraceMask)wxLog::GetTraceMask();
12724 wxPyEndAllowThreads(__tstate);
12725 if (PyErr_Occurred()) SWIG_fail;
12726 }
12727 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12728 return resultobj;
12729 fail:
12730 return NULL;
12731 }
12732
12733
12734 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12735 PyObject *resultobj = 0;
12736 wxChar *arg1 = (wxChar *) 0 ;
12737 bool result;
12738 void *argp1 = 0 ;
12739 int res1 = 0 ;
12740 PyObject * obj0 = 0 ;
12741 char * kwnames[] = {
12742 (char *) "mask", NULL
12743 };
12744
12745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12747 if (!SWIG_IsOK(res1)) {
12748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12749 }
12750 arg1 = reinterpret_cast< wxChar * >(argp1);
12751 {
12752 PyThreadState* __tstate = wxPyBeginAllowThreads();
12753 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12754 wxPyEndAllowThreads(__tstate);
12755 if (PyErr_Occurred()) SWIG_fail;
12756 }
12757 {
12758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12759 }
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12767 PyObject *resultobj = 0;
12768 wxLogLevel result;
12769
12770 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12771 {
12772 PyThreadState* __tstate = wxPyBeginAllowThreads();
12773 result = (wxLogLevel)wxLog::GetLogLevel();
12774 wxPyEndAllowThreads(__tstate);
12775 if (PyErr_Occurred()) SWIG_fail;
12776 }
12777 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12778 return resultobj;
12779 fail:
12780 return NULL;
12781 }
12782
12783
12784 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12785 PyObject *resultobj = 0;
12786 wxChar *result = 0 ;
12787
12788 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12789 {
12790 PyThreadState* __tstate = wxPyBeginAllowThreads();
12791 result = (wxChar *)wxLog::GetTimestamp();
12792 wxPyEndAllowThreads(__tstate);
12793 if (PyErr_Occurred()) SWIG_fail;
12794 }
12795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12796 return resultobj;
12797 fail:
12798 return NULL;
12799 }
12800
12801
12802 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12803 PyObject *resultobj = 0;
12804 wxString result;
12805
12806 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12807 {
12808 PyThreadState* __tstate = wxPyBeginAllowThreads();
12809 result = wxLog_TimeStamp();
12810 wxPyEndAllowThreads(__tstate);
12811 if (PyErr_Occurred()) SWIG_fail;
12812 }
12813 {
12814 #if wxUSE_UNICODE
12815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12816 #else
12817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12818 #endif
12819 }
12820 return resultobj;
12821 fail:
12822 return NULL;
12823 }
12824
12825
12826 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12827 PyObject *resultobj = 0;
12828 wxLog *arg1 = (wxLog *) 0 ;
12829 void *argp1 = 0 ;
12830 int res1 = 0 ;
12831 PyObject *swig_obj[1] ;
12832
12833 if (!args) SWIG_fail;
12834 swig_obj[0] = args;
12835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12836 if (!SWIG_IsOK(res1)) {
12837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12838 }
12839 arg1 = reinterpret_cast< wxLog * >(argp1);
12840 {
12841 PyThreadState* __tstate = wxPyBeginAllowThreads();
12842 wxLog_Destroy(arg1);
12843 wxPyEndAllowThreads(__tstate);
12844 if (PyErr_Occurred()) SWIG_fail;
12845 }
12846 resultobj = SWIG_Py_Void();
12847 return resultobj;
12848 fail:
12849 return NULL;
12850 }
12851
12852
12853 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12854 PyObject *obj;
12855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12856 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12857 return SWIG_Py_Void();
12858 }
12859
12860 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12861 return SWIG_Python_InitShadowInstance(args);
12862 }
12863
12864 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12865 PyObject *resultobj = 0;
12866 wxLogStderr *result = 0 ;
12867
12868 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12869 {
12870 PyThreadState* __tstate = wxPyBeginAllowThreads();
12871 result = (wxLogStderr *)new wxLogStderr();
12872 wxPyEndAllowThreads(__tstate);
12873 if (PyErr_Occurred()) SWIG_fail;
12874 }
12875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12876 return resultobj;
12877 fail:
12878 return NULL;
12879 }
12880
12881
12882 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12883 PyObject *obj;
12884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12885 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12886 return SWIG_Py_Void();
12887 }
12888
12889 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12890 return SWIG_Python_InitShadowInstance(args);
12891 }
12892
12893 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12894 PyObject *resultobj = 0;
12895 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12896 wxLogTextCtrl *result = 0 ;
12897 void *argp1 = 0 ;
12898 int res1 = 0 ;
12899 PyObject * obj0 = 0 ;
12900 char * kwnames[] = {
12901 (char *) "pTextCtrl", NULL
12902 };
12903
12904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12906 if (!SWIG_IsOK(res1)) {
12907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12908 }
12909 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12913 wxPyEndAllowThreads(__tstate);
12914 if (PyErr_Occurred()) SWIG_fail;
12915 }
12916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12917 return resultobj;
12918 fail:
12919 return NULL;
12920 }
12921
12922
12923 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12924 PyObject *obj;
12925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12926 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12927 return SWIG_Py_Void();
12928 }
12929
12930 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12931 return SWIG_Python_InitShadowInstance(args);
12932 }
12933
12934 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12935 PyObject *resultobj = 0;
12936 wxLogGui *result = 0 ;
12937
12938 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (wxLogGui *)new wxLogGui();
12942 wxPyEndAllowThreads(__tstate);
12943 if (PyErr_Occurred()) SWIG_fail;
12944 }
12945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12946 return resultobj;
12947 fail:
12948 return NULL;
12949 }
12950
12951
12952 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12953 PyObject *obj;
12954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12955 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12956 return SWIG_Py_Void();
12957 }
12958
12959 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12960 return SWIG_Python_InitShadowInstance(args);
12961 }
12962
12963 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12964 PyObject *resultobj = 0;
12965 wxFrame *arg1 = (wxFrame *) 0 ;
12966 wxString *arg2 = 0 ;
12967 bool arg3 = (bool) true ;
12968 bool arg4 = (bool) true ;
12969 wxLogWindow *result = 0 ;
12970 void *argp1 = 0 ;
12971 int res1 = 0 ;
12972 bool temp2 = false ;
12973 bool val3 ;
12974 int ecode3 = 0 ;
12975 bool val4 ;
12976 int ecode4 = 0 ;
12977 PyObject * obj0 = 0 ;
12978 PyObject * obj1 = 0 ;
12979 PyObject * obj2 = 0 ;
12980 PyObject * obj3 = 0 ;
12981 char * kwnames[] = {
12982 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
12983 };
12984
12985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12987 if (!SWIG_IsOK(res1)) {
12988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
12989 }
12990 arg1 = reinterpret_cast< wxFrame * >(argp1);
12991 {
12992 arg2 = wxString_in_helper(obj1);
12993 if (arg2 == NULL) SWIG_fail;
12994 temp2 = true;
12995 }
12996 if (obj2) {
12997 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12998 if (!SWIG_IsOK(ecode3)) {
12999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13000 }
13001 arg3 = static_cast< bool >(val3);
13002 }
13003 if (obj3) {
13004 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13005 if (!SWIG_IsOK(ecode4)) {
13006 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13007 }
13008 arg4 = static_cast< bool >(val4);
13009 }
13010 {
13011 PyThreadState* __tstate = wxPyBeginAllowThreads();
13012 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13013 wxPyEndAllowThreads(__tstate);
13014 if (PyErr_Occurred()) SWIG_fail;
13015 }
13016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13017 {
13018 if (temp2)
13019 delete arg2;
13020 }
13021 return resultobj;
13022 fail:
13023 {
13024 if (temp2)
13025 delete arg2;
13026 }
13027 return NULL;
13028 }
13029
13030
13031 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13032 PyObject *resultobj = 0;
13033 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13034 bool arg2 = (bool) true ;
13035 void *argp1 = 0 ;
13036 int res1 = 0 ;
13037 bool val2 ;
13038 int ecode2 = 0 ;
13039 PyObject * obj0 = 0 ;
13040 PyObject * obj1 = 0 ;
13041 char * kwnames[] = {
13042 (char *) "self",(char *) "bShow", NULL
13043 };
13044
13045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13047 if (!SWIG_IsOK(res1)) {
13048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13049 }
13050 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13051 if (obj1) {
13052 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13053 if (!SWIG_IsOK(ecode2)) {
13054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13055 }
13056 arg2 = static_cast< bool >(val2);
13057 }
13058 {
13059 PyThreadState* __tstate = wxPyBeginAllowThreads();
13060 (arg1)->Show(arg2);
13061 wxPyEndAllowThreads(__tstate);
13062 if (PyErr_Occurred()) SWIG_fail;
13063 }
13064 resultobj = SWIG_Py_Void();
13065 return resultobj;
13066 fail:
13067 return NULL;
13068 }
13069
13070
13071 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13072 PyObject *resultobj = 0;
13073 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13074 wxFrame *result = 0 ;
13075 void *argp1 = 0 ;
13076 int res1 = 0 ;
13077 PyObject *swig_obj[1] ;
13078
13079 if (!args) SWIG_fail;
13080 swig_obj[0] = args;
13081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13082 if (!SWIG_IsOK(res1)) {
13083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13084 }
13085 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13086 {
13087 PyThreadState* __tstate = wxPyBeginAllowThreads();
13088 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13089 wxPyEndAllowThreads(__tstate);
13090 if (PyErr_Occurred()) SWIG_fail;
13091 }
13092 {
13093 resultobj = wxPyMake_wxObject(result, (bool)0);
13094 }
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13102 PyObject *resultobj = 0;
13103 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13104 wxLog *result = 0 ;
13105 void *argp1 = 0 ;
13106 int res1 = 0 ;
13107 PyObject *swig_obj[1] ;
13108
13109 if (!args) SWIG_fail;
13110 swig_obj[0] = args;
13111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13112 if (!SWIG_IsOK(res1)) {
13113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13114 }
13115 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13116 {
13117 PyThreadState* __tstate = wxPyBeginAllowThreads();
13118 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13123 return resultobj;
13124 fail:
13125 return NULL;
13126 }
13127
13128
13129 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13130 PyObject *resultobj = 0;
13131 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13132 bool result;
13133 void *argp1 = 0 ;
13134 int res1 = 0 ;
13135 PyObject *swig_obj[1] ;
13136
13137 if (!args) SWIG_fail;
13138 swig_obj[0] = args;
13139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13140 if (!SWIG_IsOK(res1)) {
13141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13142 }
13143 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13144 {
13145 PyThreadState* __tstate = wxPyBeginAllowThreads();
13146 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13147 wxPyEndAllowThreads(__tstate);
13148 if (PyErr_Occurred()) SWIG_fail;
13149 }
13150 {
13151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13152 }
13153 return resultobj;
13154 fail:
13155 return NULL;
13156 }
13157
13158
13159 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13160 PyObject *resultobj = 0;
13161 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13162 bool arg2 ;
13163 void *argp1 = 0 ;
13164 int res1 = 0 ;
13165 bool val2 ;
13166 int ecode2 = 0 ;
13167 PyObject * obj0 = 0 ;
13168 PyObject * obj1 = 0 ;
13169 char * kwnames[] = {
13170 (char *) "self",(char *) "bDoPass", NULL
13171 };
13172
13173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13175 if (!SWIG_IsOK(res1)) {
13176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13177 }
13178 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13179 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13180 if (!SWIG_IsOK(ecode2)) {
13181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13182 }
13183 arg2 = static_cast< bool >(val2);
13184 {
13185 PyThreadState* __tstate = wxPyBeginAllowThreads();
13186 (arg1)->PassMessages(arg2);
13187 wxPyEndAllowThreads(__tstate);
13188 if (PyErr_Occurred()) SWIG_fail;
13189 }
13190 resultobj = SWIG_Py_Void();
13191 return resultobj;
13192 fail:
13193 return NULL;
13194 }
13195
13196
13197 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13198 PyObject *obj;
13199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13200 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13201 return SWIG_Py_Void();
13202 }
13203
13204 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13205 return SWIG_Python_InitShadowInstance(args);
13206 }
13207
13208 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13209 PyObject *resultobj = 0;
13210 wxLog *arg1 = (wxLog *) 0 ;
13211 wxLogChain *result = 0 ;
13212 void *argp1 = 0 ;
13213 int res1 = 0 ;
13214 PyObject * obj0 = 0 ;
13215 char * kwnames[] = {
13216 (char *) "logger", NULL
13217 };
13218
13219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13221 if (!SWIG_IsOK(res1)) {
13222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13223 }
13224 arg1 = reinterpret_cast< wxLog * >(argp1);
13225 {
13226 PyThreadState* __tstate = wxPyBeginAllowThreads();
13227 result = (wxLogChain *)new wxLogChain(arg1);
13228 wxPyEndAllowThreads(__tstate);
13229 if (PyErr_Occurred()) SWIG_fail;
13230 }
13231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13232 return resultobj;
13233 fail:
13234 return NULL;
13235 }
13236
13237
13238 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13239 PyObject *resultobj = 0;
13240 wxLogChain *arg1 = (wxLogChain *) 0 ;
13241 wxLog *arg2 = (wxLog *) 0 ;
13242 void *argp1 = 0 ;
13243 int res1 = 0 ;
13244 void *argp2 = 0 ;
13245 int res2 = 0 ;
13246 PyObject * obj0 = 0 ;
13247 PyObject * obj1 = 0 ;
13248 char * kwnames[] = {
13249 (char *) "self",(char *) "logger", NULL
13250 };
13251
13252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13254 if (!SWIG_IsOK(res1)) {
13255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13256 }
13257 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13259 if (!SWIG_IsOK(res2)) {
13260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13261 }
13262 arg2 = reinterpret_cast< wxLog * >(argp2);
13263 {
13264 PyThreadState* __tstate = wxPyBeginAllowThreads();
13265 (arg1)->SetLog(arg2);
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 resultobj = SWIG_Py_Void();
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13277 PyObject *resultobj = 0;
13278 wxLogChain *arg1 = (wxLogChain *) 0 ;
13279 bool arg2 ;
13280 void *argp1 = 0 ;
13281 int res1 = 0 ;
13282 bool val2 ;
13283 int ecode2 = 0 ;
13284 PyObject * obj0 = 0 ;
13285 PyObject * obj1 = 0 ;
13286 char * kwnames[] = {
13287 (char *) "self",(char *) "bDoPass", NULL
13288 };
13289
13290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13292 if (!SWIG_IsOK(res1)) {
13293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13294 }
13295 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13296 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13297 if (!SWIG_IsOK(ecode2)) {
13298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13299 }
13300 arg2 = static_cast< bool >(val2);
13301 {
13302 PyThreadState* __tstate = wxPyBeginAllowThreads();
13303 (arg1)->PassMessages(arg2);
13304 wxPyEndAllowThreads(__tstate);
13305 if (PyErr_Occurred()) SWIG_fail;
13306 }
13307 resultobj = SWIG_Py_Void();
13308 return resultobj;
13309 fail:
13310 return NULL;
13311 }
13312
13313
13314 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13315 PyObject *resultobj = 0;
13316 wxLogChain *arg1 = (wxLogChain *) 0 ;
13317 bool result;
13318 void *argp1 = 0 ;
13319 int res1 = 0 ;
13320 PyObject *swig_obj[1] ;
13321
13322 if (!args) SWIG_fail;
13323 swig_obj[0] = args;
13324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13325 if (!SWIG_IsOK(res1)) {
13326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13327 }
13328 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 result = (bool)(arg1)->IsPassingMessages();
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 {
13336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13337 }
13338 return resultobj;
13339 fail:
13340 return NULL;
13341 }
13342
13343
13344 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13345 PyObject *resultobj = 0;
13346 wxLogChain *arg1 = (wxLogChain *) 0 ;
13347 wxLog *result = 0 ;
13348 void *argp1 = 0 ;
13349 int res1 = 0 ;
13350 PyObject *swig_obj[1] ;
13351
13352 if (!args) SWIG_fail;
13353 swig_obj[0] = args;
13354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13355 if (!SWIG_IsOK(res1)) {
13356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13357 }
13358 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13359 {
13360 PyThreadState* __tstate = wxPyBeginAllowThreads();
13361 result = (wxLog *)(arg1)->GetOldLog();
13362 wxPyEndAllowThreads(__tstate);
13363 if (PyErr_Occurred()) SWIG_fail;
13364 }
13365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13366 return resultobj;
13367 fail:
13368 return NULL;
13369 }
13370
13371
13372 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13373 PyObject *obj;
13374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13375 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13376 return SWIG_Py_Void();
13377 }
13378
13379 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13380 return SWIG_Python_InitShadowInstance(args);
13381 }
13382
13383 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13384 PyObject *resultobj = 0;
13385 wxLogBuffer *result = 0 ;
13386
13387 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13388 {
13389 PyThreadState* __tstate = wxPyBeginAllowThreads();
13390 result = (wxLogBuffer *)new wxLogBuffer();
13391 wxPyEndAllowThreads(__tstate);
13392 if (PyErr_Occurred()) SWIG_fail;
13393 }
13394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13395 return resultobj;
13396 fail:
13397 return NULL;
13398 }
13399
13400
13401 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13402 PyObject *resultobj = 0;
13403 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13404 wxString *result = 0 ;
13405 void *argp1 = 0 ;
13406 int res1 = 0 ;
13407 PyObject *swig_obj[1] ;
13408
13409 if (!args) SWIG_fail;
13410 swig_obj[0] = args;
13411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13412 if (!SWIG_IsOK(res1)) {
13413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13414 }
13415 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13416 {
13417 PyThreadState* __tstate = wxPyBeginAllowThreads();
13418 {
13419 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13420 result = (wxString *) &_result_ref;
13421 }
13422 wxPyEndAllowThreads(__tstate);
13423 if (PyErr_Occurred()) SWIG_fail;
13424 }
13425 {
13426 #if wxUSE_UNICODE
13427 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13428 #else
13429 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13430 #endif
13431 }
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439 PyObject *obj;
13440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13441 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13442 return SWIG_Py_Void();
13443 }
13444
13445 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13446 return SWIG_Python_InitShadowInstance(args);
13447 }
13448
13449 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13450 PyObject *resultobj = 0;
13451 unsigned long result;
13452
13453 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13454 {
13455 PyThreadState* __tstate = wxPyBeginAllowThreads();
13456 result = (unsigned long)wxSysErrorCode();
13457 wxPyEndAllowThreads(__tstate);
13458 if (PyErr_Occurred()) SWIG_fail;
13459 }
13460 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13461 return resultobj;
13462 fail:
13463 return NULL;
13464 }
13465
13466
13467 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13468 PyObject *resultobj = 0;
13469 unsigned long arg1 = (unsigned long) 0 ;
13470 wxString result;
13471 unsigned long val1 ;
13472 int ecode1 = 0 ;
13473 PyObject * obj0 = 0 ;
13474 char * kwnames[] = {
13475 (char *) "nErrCode", NULL
13476 };
13477
13478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13479 if (obj0) {
13480 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13481 if (!SWIG_IsOK(ecode1)) {
13482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13483 }
13484 arg1 = static_cast< unsigned long >(val1);
13485 }
13486 {
13487 PyThreadState* __tstate = wxPyBeginAllowThreads();
13488 result = wxSysErrorMsg(arg1);
13489 wxPyEndAllowThreads(__tstate);
13490 if (PyErr_Occurred()) SWIG_fail;
13491 }
13492 {
13493 #if wxUSE_UNICODE
13494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13495 #else
13496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13497 #endif
13498 }
13499 return resultobj;
13500 fail:
13501 return NULL;
13502 }
13503
13504
13505 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13506 PyObject *resultobj = 0;
13507 wxString *arg1 = 0 ;
13508 bool temp1 = false ;
13509 PyObject * obj0 = 0 ;
13510 char * kwnames[] = {
13511 (char *) "msg", NULL
13512 };
13513
13514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13515 {
13516 arg1 = wxString_in_helper(obj0);
13517 if (arg1 == NULL) SWIG_fail;
13518 temp1 = true;
13519 }
13520 {
13521 PyThreadState* __tstate = wxPyBeginAllowThreads();
13522 wxPyLogFatalError((wxString const &)*arg1);
13523 wxPyEndAllowThreads(__tstate);
13524 if (PyErr_Occurred()) SWIG_fail;
13525 }
13526 resultobj = SWIG_Py_Void();
13527 {
13528 if (temp1)
13529 delete arg1;
13530 }
13531 return resultobj;
13532 fail:
13533 {
13534 if (temp1)
13535 delete arg1;
13536 }
13537 return NULL;
13538 }
13539
13540
13541 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj = 0;
13543 wxString *arg1 = 0 ;
13544 bool temp1 = false ;
13545 PyObject * obj0 = 0 ;
13546 char * kwnames[] = {
13547 (char *) "msg", NULL
13548 };
13549
13550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13551 {
13552 arg1 = wxString_in_helper(obj0);
13553 if (arg1 == NULL) SWIG_fail;
13554 temp1 = true;
13555 }
13556 {
13557 PyThreadState* __tstate = wxPyBeginAllowThreads();
13558 wxPyLogError((wxString const &)*arg1);
13559 wxPyEndAllowThreads(__tstate);
13560 if (PyErr_Occurred()) SWIG_fail;
13561 }
13562 resultobj = SWIG_Py_Void();
13563 {
13564 if (temp1)
13565 delete arg1;
13566 }
13567 return resultobj;
13568 fail:
13569 {
13570 if (temp1)
13571 delete arg1;
13572 }
13573 return NULL;
13574 }
13575
13576
13577 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13578 PyObject *resultobj = 0;
13579 wxString *arg1 = 0 ;
13580 bool temp1 = false ;
13581 PyObject * obj0 = 0 ;
13582 char * kwnames[] = {
13583 (char *) "msg", NULL
13584 };
13585
13586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13587 {
13588 arg1 = wxString_in_helper(obj0);
13589 if (arg1 == NULL) SWIG_fail;
13590 temp1 = true;
13591 }
13592 {
13593 PyThreadState* __tstate = wxPyBeginAllowThreads();
13594 wxPyLogWarning((wxString const &)*arg1);
13595 wxPyEndAllowThreads(__tstate);
13596 if (PyErr_Occurred()) SWIG_fail;
13597 }
13598 resultobj = SWIG_Py_Void();
13599 {
13600 if (temp1)
13601 delete arg1;
13602 }
13603 return resultobj;
13604 fail:
13605 {
13606 if (temp1)
13607 delete arg1;
13608 }
13609 return NULL;
13610 }
13611
13612
13613 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13614 PyObject *resultobj = 0;
13615 wxString *arg1 = 0 ;
13616 bool temp1 = false ;
13617 PyObject * obj0 = 0 ;
13618 char * kwnames[] = {
13619 (char *) "msg", NULL
13620 };
13621
13622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13623 {
13624 arg1 = wxString_in_helper(obj0);
13625 if (arg1 == NULL) SWIG_fail;
13626 temp1 = true;
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 wxPyLogMessage((wxString const &)*arg1);
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 resultobj = SWIG_Py_Void();
13635 {
13636 if (temp1)
13637 delete arg1;
13638 }
13639 return resultobj;
13640 fail:
13641 {
13642 if (temp1)
13643 delete arg1;
13644 }
13645 return NULL;
13646 }
13647
13648
13649 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj = 0;
13651 wxString *arg1 = 0 ;
13652 bool temp1 = false ;
13653 PyObject * obj0 = 0 ;
13654 char * kwnames[] = {
13655 (char *) "msg", NULL
13656 };
13657
13658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13659 {
13660 arg1 = wxString_in_helper(obj0);
13661 if (arg1 == NULL) SWIG_fail;
13662 temp1 = true;
13663 }
13664 {
13665 PyThreadState* __tstate = wxPyBeginAllowThreads();
13666 wxPyLogInfo((wxString const &)*arg1);
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 resultobj = SWIG_Py_Void();
13671 {
13672 if (temp1)
13673 delete arg1;
13674 }
13675 return resultobj;
13676 fail:
13677 {
13678 if (temp1)
13679 delete arg1;
13680 }
13681 return NULL;
13682 }
13683
13684
13685 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj = 0;
13687 wxString *arg1 = 0 ;
13688 bool temp1 = false ;
13689 PyObject * obj0 = 0 ;
13690 char * kwnames[] = {
13691 (char *) "msg", NULL
13692 };
13693
13694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13695 {
13696 arg1 = wxString_in_helper(obj0);
13697 if (arg1 == NULL) SWIG_fail;
13698 temp1 = true;
13699 }
13700 {
13701 PyThreadState* __tstate = wxPyBeginAllowThreads();
13702 wxPyLogDebug((wxString const &)*arg1);
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 resultobj = SWIG_Py_Void();
13707 {
13708 if (temp1)
13709 delete arg1;
13710 }
13711 return resultobj;
13712 fail:
13713 {
13714 if (temp1)
13715 delete arg1;
13716 }
13717 return NULL;
13718 }
13719
13720
13721 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13722 PyObject *resultobj = 0;
13723 wxString *arg1 = 0 ;
13724 bool temp1 = false ;
13725 PyObject * obj0 = 0 ;
13726 char * kwnames[] = {
13727 (char *) "msg", NULL
13728 };
13729
13730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13731 {
13732 arg1 = wxString_in_helper(obj0);
13733 if (arg1 == NULL) SWIG_fail;
13734 temp1 = true;
13735 }
13736 {
13737 PyThreadState* __tstate = wxPyBeginAllowThreads();
13738 wxPyLogVerbose((wxString const &)*arg1);
13739 wxPyEndAllowThreads(__tstate);
13740 if (PyErr_Occurred()) SWIG_fail;
13741 }
13742 resultobj = SWIG_Py_Void();
13743 {
13744 if (temp1)
13745 delete arg1;
13746 }
13747 return resultobj;
13748 fail:
13749 {
13750 if (temp1)
13751 delete arg1;
13752 }
13753 return NULL;
13754 }
13755
13756
13757 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj = 0;
13759 wxString *arg1 = 0 ;
13760 bool temp1 = false ;
13761 PyObject * obj0 = 0 ;
13762 char * kwnames[] = {
13763 (char *) "msg", NULL
13764 };
13765
13766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13767 {
13768 arg1 = wxString_in_helper(obj0);
13769 if (arg1 == NULL) SWIG_fail;
13770 temp1 = true;
13771 }
13772 {
13773 PyThreadState* __tstate = wxPyBeginAllowThreads();
13774 wxPyLogStatus((wxString const &)*arg1);
13775 wxPyEndAllowThreads(__tstate);
13776 if (PyErr_Occurred()) SWIG_fail;
13777 }
13778 resultobj = SWIG_Py_Void();
13779 {
13780 if (temp1)
13781 delete arg1;
13782 }
13783 return resultobj;
13784 fail:
13785 {
13786 if (temp1)
13787 delete arg1;
13788 }
13789 return NULL;
13790 }
13791
13792
13793 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13794 PyObject *resultobj = 0;
13795 wxFrame *arg1 = (wxFrame *) 0 ;
13796 wxString *arg2 = 0 ;
13797 void *argp1 = 0 ;
13798 int res1 = 0 ;
13799 bool temp2 = false ;
13800 PyObject * obj0 = 0 ;
13801 PyObject * obj1 = 0 ;
13802 char * kwnames[] = {
13803 (char *) "pFrame",(char *) "msg", NULL
13804 };
13805
13806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13808 if (!SWIG_IsOK(res1)) {
13809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13810 }
13811 arg1 = reinterpret_cast< wxFrame * >(argp1);
13812 {
13813 arg2 = wxString_in_helper(obj1);
13814 if (arg2 == NULL) SWIG_fail;
13815 temp2 = true;
13816 }
13817 {
13818 PyThreadState* __tstate = wxPyBeginAllowThreads();
13819 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13820 wxPyEndAllowThreads(__tstate);
13821 if (PyErr_Occurred()) SWIG_fail;
13822 }
13823 resultobj = SWIG_Py_Void();
13824 {
13825 if (temp2)
13826 delete arg2;
13827 }
13828 return resultobj;
13829 fail:
13830 {
13831 if (temp2)
13832 delete arg2;
13833 }
13834 return NULL;
13835 }
13836
13837
13838 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13839 PyObject *resultobj = 0;
13840 wxString *arg1 = 0 ;
13841 bool temp1 = false ;
13842 PyObject * obj0 = 0 ;
13843 char * kwnames[] = {
13844 (char *) "msg", NULL
13845 };
13846
13847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13848 {
13849 arg1 = wxString_in_helper(obj0);
13850 if (arg1 == NULL) SWIG_fail;
13851 temp1 = true;
13852 }
13853 {
13854 PyThreadState* __tstate = wxPyBeginAllowThreads();
13855 wxPyLogSysError((wxString const &)*arg1);
13856 wxPyEndAllowThreads(__tstate);
13857 if (PyErr_Occurred()) SWIG_fail;
13858 }
13859 resultobj = SWIG_Py_Void();
13860 {
13861 if (temp1)
13862 delete arg1;
13863 }
13864 return resultobj;
13865 fail:
13866 {
13867 if (temp1)
13868 delete arg1;
13869 }
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = 0;
13876 unsigned long arg1 ;
13877 wxString *arg2 = 0 ;
13878 unsigned long val1 ;
13879 int ecode1 = 0 ;
13880 bool temp2 = false ;
13881 PyObject * obj0 = 0 ;
13882 PyObject * obj1 = 0 ;
13883 char * kwnames[] = {
13884 (char *) "level",(char *) "msg", NULL
13885 };
13886
13887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13888 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13889 if (!SWIG_IsOK(ecode1)) {
13890 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13891 }
13892 arg1 = static_cast< unsigned long >(val1);
13893 {
13894 arg2 = wxString_in_helper(obj1);
13895 if (arg2 == NULL) SWIG_fail;
13896 temp2 = true;
13897 }
13898 {
13899 PyThreadState* __tstate = wxPyBeginAllowThreads();
13900 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13901 wxPyEndAllowThreads(__tstate);
13902 if (PyErr_Occurred()) SWIG_fail;
13903 }
13904 resultobj = SWIG_Py_Void();
13905 {
13906 if (temp2)
13907 delete arg2;
13908 }
13909 return resultobj;
13910 fail:
13911 {
13912 if (temp2)
13913 delete arg2;
13914 }
13915 return NULL;
13916 }
13917
13918
13919 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13920 PyObject *resultobj = 0;
13921 unsigned long arg1 ;
13922 wxString *arg2 = 0 ;
13923 unsigned long val1 ;
13924 int ecode1 = 0 ;
13925 bool temp2 = false ;
13926
13927 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13928 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13929 if (!SWIG_IsOK(ecode1)) {
13930 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13931 }
13932 arg1 = static_cast< unsigned long >(val1);
13933 {
13934 arg2 = wxString_in_helper(swig_obj[1]);
13935 if (arg2 == NULL) SWIG_fail;
13936 temp2 = true;
13937 }
13938 {
13939 PyThreadState* __tstate = wxPyBeginAllowThreads();
13940 wxPyLogTrace(arg1,(wxString const &)*arg2);
13941 wxPyEndAllowThreads(__tstate);
13942 if (PyErr_Occurred()) SWIG_fail;
13943 }
13944 resultobj = SWIG_Py_Void();
13945 {
13946 if (temp2)
13947 delete arg2;
13948 }
13949 return resultobj;
13950 fail:
13951 {
13952 if (temp2)
13953 delete arg2;
13954 }
13955 return NULL;
13956 }
13957
13958
13959 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13960 PyObject *resultobj = 0;
13961 wxString *arg1 = 0 ;
13962 wxString *arg2 = 0 ;
13963 bool temp1 = false ;
13964 bool temp2 = false ;
13965
13966 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13967 {
13968 arg1 = wxString_in_helper(swig_obj[0]);
13969 if (arg1 == NULL) SWIG_fail;
13970 temp1 = true;
13971 }
13972 {
13973 arg2 = wxString_in_helper(swig_obj[1]);
13974 if (arg2 == NULL) SWIG_fail;
13975 temp2 = true;
13976 }
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
13980 wxPyEndAllowThreads(__tstate);
13981 if (PyErr_Occurred()) SWIG_fail;
13982 }
13983 resultobj = SWIG_Py_Void();
13984 {
13985 if (temp1)
13986 delete arg1;
13987 }
13988 {
13989 if (temp2)
13990 delete arg2;
13991 }
13992 return resultobj;
13993 fail:
13994 {
13995 if (temp1)
13996 delete arg1;
13997 }
13998 {
13999 if (temp2)
14000 delete arg2;
14001 }
14002 return NULL;
14003 }
14004
14005
14006 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14007 int argc;
14008 PyObject *argv[3];
14009
14010 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14011 --argc;
14012 if (argc == 2) {
14013 int _v = 0;
14014 {
14015 {
14016 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14017 }
14018 }
14019 if (!_v) goto check_1;
14020 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14021 }
14022 check_1:
14023
14024 if (argc == 2) {
14025 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14026 }
14027
14028 fail:
14029 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14030 return NULL;
14031 }
14032
14033
14034 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14035 PyObject *resultobj = 0;
14036 wxString *arg1 = 0 ;
14037 wxString *arg2 = 0 ;
14038 bool temp1 = false ;
14039 bool temp2 = false ;
14040 PyObject * obj0 = 0 ;
14041 PyObject * obj1 = 0 ;
14042 char * kwnames[] = {
14043 (char *) "title",(char *) "text", NULL
14044 };
14045
14046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14047 {
14048 arg1 = wxString_in_helper(obj0);
14049 if (arg1 == NULL) SWIG_fail;
14050 temp1 = true;
14051 }
14052 {
14053 arg2 = wxString_in_helper(obj1);
14054 if (arg2 == NULL) SWIG_fail;
14055 temp2 = true;
14056 }
14057 {
14058 PyThreadState* __tstate = wxPyBeginAllowThreads();
14059 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14060 wxPyEndAllowThreads(__tstate);
14061 if (PyErr_Occurred()) SWIG_fail;
14062 }
14063 resultobj = SWIG_Py_Void();
14064 {
14065 if (temp1)
14066 delete arg1;
14067 }
14068 {
14069 if (temp2)
14070 delete arg2;
14071 }
14072 return resultobj;
14073 fail:
14074 {
14075 if (temp1)
14076 delete arg1;
14077 }
14078 {
14079 if (temp2)
14080 delete arg2;
14081 }
14082 return NULL;
14083 }
14084
14085
14086 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14087 PyObject *resultobj = 0;
14088 wxLogNull *result = 0 ;
14089
14090 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14091 {
14092 PyThreadState* __tstate = wxPyBeginAllowThreads();
14093 result = (wxLogNull *)new wxLogNull();
14094 wxPyEndAllowThreads(__tstate);
14095 if (PyErr_Occurred()) SWIG_fail;
14096 }
14097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14098 return resultobj;
14099 fail:
14100 return NULL;
14101 }
14102
14103
14104 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14105 PyObject *resultobj = 0;
14106 wxLogNull *arg1 = (wxLogNull *) 0 ;
14107 void *argp1 = 0 ;
14108 int res1 = 0 ;
14109 PyObject *swig_obj[1] ;
14110
14111 if (!args) SWIG_fail;
14112 swig_obj[0] = args;
14113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14114 if (!SWIG_IsOK(res1)) {
14115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14116 }
14117 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 delete arg1;
14121
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 resultobj = SWIG_Py_Void();
14126 return resultobj;
14127 fail:
14128 return NULL;
14129 }
14130
14131
14132 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14133 PyObject *obj;
14134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14135 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14136 return SWIG_Py_Void();
14137 }
14138
14139 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14140 return SWIG_Python_InitShadowInstance(args);
14141 }
14142
14143 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14144 PyObject *resultobj = 0;
14145 wxPyLog *result = 0 ;
14146
14147 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14148 {
14149 PyThreadState* __tstate = wxPyBeginAllowThreads();
14150 result = (wxPyLog *)new wxPyLog();
14151 wxPyEndAllowThreads(__tstate);
14152 if (PyErr_Occurred()) SWIG_fail;
14153 }
14154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14155 return resultobj;
14156 fail:
14157 return NULL;
14158 }
14159
14160
14161 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14162 PyObject *resultobj = 0;
14163 wxPyLog *arg1 = (wxPyLog *) 0 ;
14164 PyObject *arg2 = (PyObject *) 0 ;
14165 PyObject *arg3 = (PyObject *) 0 ;
14166 void *argp1 = 0 ;
14167 int res1 = 0 ;
14168 PyObject * obj0 = 0 ;
14169 PyObject * obj1 = 0 ;
14170 PyObject * obj2 = 0 ;
14171 char * kwnames[] = {
14172 (char *) "self",(char *) "self",(char *) "_class", NULL
14173 };
14174
14175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14177 if (!SWIG_IsOK(res1)) {
14178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14179 }
14180 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14181 arg2 = obj1;
14182 arg3 = obj2;
14183 {
14184 PyThreadState* __tstate = wxPyBeginAllowThreads();
14185 (arg1)->_setCallbackInfo(arg2,arg3);
14186 wxPyEndAllowThreads(__tstate);
14187 if (PyErr_Occurred()) SWIG_fail;
14188 }
14189 resultobj = SWIG_Py_Void();
14190 return resultobj;
14191 fail:
14192 return NULL;
14193 }
14194
14195
14196 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14197 PyObject *obj;
14198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14199 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14200 return SWIG_Py_Void();
14201 }
14202
14203 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14204 return SWIG_Python_InitShadowInstance(args);
14205 }
14206
14207 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14208 PyObject *resultobj = 0;
14209 int arg1 ;
14210 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14211 int arg3 = (int) wxKILL_NOCHILDREN ;
14212 wxKillError result;
14213 int val1 ;
14214 int ecode1 = 0 ;
14215 int val2 ;
14216 int ecode2 = 0 ;
14217 int val3 ;
14218 int ecode3 = 0 ;
14219 PyObject * obj0 = 0 ;
14220 PyObject * obj1 = 0 ;
14221 PyObject * obj2 = 0 ;
14222 char * kwnames[] = {
14223 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14224 };
14225
14226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14227 ecode1 = SWIG_AsVal_int(obj0, &val1);
14228 if (!SWIG_IsOK(ecode1)) {
14229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14230 }
14231 arg1 = static_cast< int >(val1);
14232 if (obj1) {
14233 ecode2 = SWIG_AsVal_int(obj1, &val2);
14234 if (!SWIG_IsOK(ecode2)) {
14235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14236 }
14237 arg2 = static_cast< wxSignal >(val2);
14238 }
14239 if (obj2) {
14240 ecode3 = SWIG_AsVal_int(obj2, &val3);
14241 if (!SWIG_IsOK(ecode3)) {
14242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14243 }
14244 arg3 = static_cast< int >(val3);
14245 }
14246 {
14247 PyThreadState* __tstate = wxPyBeginAllowThreads();
14248 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14249 wxPyEndAllowThreads(__tstate);
14250 if (PyErr_Occurred()) SWIG_fail;
14251 }
14252 resultobj = SWIG_From_int(static_cast< int >(result));
14253 return resultobj;
14254 fail:
14255 return NULL;
14256 }
14257
14258
14259 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14260 PyObject *resultobj = 0;
14261 int arg1 ;
14262 bool result;
14263 int val1 ;
14264 int ecode1 = 0 ;
14265 PyObject * obj0 = 0 ;
14266 char * kwnames[] = {
14267 (char *) "pid", NULL
14268 };
14269
14270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14271 ecode1 = SWIG_AsVal_int(obj0, &val1);
14272 if (!SWIG_IsOK(ecode1)) {
14273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14274 }
14275 arg1 = static_cast< int >(val1);
14276 {
14277 PyThreadState* __tstate = wxPyBeginAllowThreads();
14278 result = (bool)wxPyProcess::Exists(arg1);
14279 wxPyEndAllowThreads(__tstate);
14280 if (PyErr_Occurred()) SWIG_fail;
14281 }
14282 {
14283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14284 }
14285 return resultobj;
14286 fail:
14287 return NULL;
14288 }
14289
14290
14291 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14292 PyObject *resultobj = 0;
14293 wxString *arg1 = 0 ;
14294 int arg2 = (int) wxEXEC_ASYNC ;
14295 wxPyProcess *result = 0 ;
14296 bool temp1 = false ;
14297 int val2 ;
14298 int ecode2 = 0 ;
14299 PyObject * obj0 = 0 ;
14300 PyObject * obj1 = 0 ;
14301 char * kwnames[] = {
14302 (char *) "cmd",(char *) "flags", NULL
14303 };
14304
14305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14306 {
14307 arg1 = wxString_in_helper(obj0);
14308 if (arg1 == NULL) SWIG_fail;
14309 temp1 = true;
14310 }
14311 if (obj1) {
14312 ecode2 = SWIG_AsVal_int(obj1, &val2);
14313 if (!SWIG_IsOK(ecode2)) {
14314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14315 }
14316 arg2 = static_cast< int >(val2);
14317 }
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14325 {
14326 if (temp1)
14327 delete arg1;
14328 }
14329 return resultobj;
14330 fail:
14331 {
14332 if (temp1)
14333 delete arg1;
14334 }
14335 return NULL;
14336 }
14337
14338
14339 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14340 PyObject *resultobj = 0;
14341 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14342 int arg2 = (int) -1 ;
14343 wxPyProcess *result = 0 ;
14344 void *argp1 = 0 ;
14345 int res1 = 0 ;
14346 int val2 ;
14347 int ecode2 = 0 ;
14348 PyObject * obj0 = 0 ;
14349 PyObject * obj1 = 0 ;
14350 char * kwnames[] = {
14351 (char *) "parent",(char *) "id", NULL
14352 };
14353
14354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14355 if (obj0) {
14356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14357 if (!SWIG_IsOK(res1)) {
14358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14359 }
14360 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14361 }
14362 if (obj1) {
14363 ecode2 = SWIG_AsVal_int(obj1, &val2);
14364 if (!SWIG_IsOK(ecode2)) {
14365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14366 }
14367 arg2 = static_cast< int >(val2);
14368 }
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14372 wxPyEndAllowThreads(__tstate);
14373 if (PyErr_Occurred()) SWIG_fail;
14374 }
14375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14376 return resultobj;
14377 fail:
14378 return NULL;
14379 }
14380
14381
14382 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14383 PyObject *resultobj = 0;
14384 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14385 PyObject *arg2 = (PyObject *) 0 ;
14386 PyObject *arg3 = (PyObject *) 0 ;
14387 void *argp1 = 0 ;
14388 int res1 = 0 ;
14389 PyObject * obj0 = 0 ;
14390 PyObject * obj1 = 0 ;
14391 PyObject * obj2 = 0 ;
14392 char * kwnames[] = {
14393 (char *) "self",(char *) "self",(char *) "_class", NULL
14394 };
14395
14396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14398 if (!SWIG_IsOK(res1)) {
14399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14400 }
14401 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14402 arg2 = obj1;
14403 arg3 = obj2;
14404 {
14405 PyThreadState* __tstate = wxPyBeginAllowThreads();
14406 (arg1)->_setCallbackInfo(arg2,arg3);
14407 wxPyEndAllowThreads(__tstate);
14408 if (PyErr_Occurred()) SWIG_fail;
14409 }
14410 resultobj = SWIG_Py_Void();
14411 return resultobj;
14412 fail:
14413 return NULL;
14414 }
14415
14416
14417 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14418 PyObject *resultobj = 0;
14419 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14420 int arg2 ;
14421 int arg3 ;
14422 void *argp1 = 0 ;
14423 int res1 = 0 ;
14424 int val2 ;
14425 int ecode2 = 0 ;
14426 int val3 ;
14427 int ecode3 = 0 ;
14428 PyObject * obj0 = 0 ;
14429 PyObject * obj1 = 0 ;
14430 PyObject * obj2 = 0 ;
14431 char * kwnames[] = {
14432 (char *) "self",(char *) "pid",(char *) "status", NULL
14433 };
14434
14435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14437 if (!SWIG_IsOK(res1)) {
14438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14439 }
14440 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14441 ecode2 = SWIG_AsVal_int(obj1, &val2);
14442 if (!SWIG_IsOK(ecode2)) {
14443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14444 }
14445 arg2 = static_cast< int >(val2);
14446 ecode3 = SWIG_AsVal_int(obj2, &val3);
14447 if (!SWIG_IsOK(ecode3)) {
14448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14449 }
14450 arg3 = static_cast< int >(val3);
14451 {
14452 PyThreadState* __tstate = wxPyBeginAllowThreads();
14453 (arg1)->OnTerminate(arg2,arg3);
14454 wxPyEndAllowThreads(__tstate);
14455 if (PyErr_Occurred()) SWIG_fail;
14456 }
14457 resultobj = SWIG_Py_Void();
14458 return resultobj;
14459 fail:
14460 return NULL;
14461 }
14462
14463
14464 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14465 PyObject *resultobj = 0;
14466 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14467 void *argp1 = 0 ;
14468 int res1 = 0 ;
14469 PyObject *swig_obj[1] ;
14470
14471 if (!args) SWIG_fail;
14472 swig_obj[0] = args;
14473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14474 if (!SWIG_IsOK(res1)) {
14475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14476 }
14477 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14478 {
14479 PyThreadState* __tstate = wxPyBeginAllowThreads();
14480 (arg1)->Redirect();
14481 wxPyEndAllowThreads(__tstate);
14482 if (PyErr_Occurred()) SWIG_fail;
14483 }
14484 resultobj = SWIG_Py_Void();
14485 return resultobj;
14486 fail:
14487 return NULL;
14488 }
14489
14490
14491 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14492 PyObject *resultobj = 0;
14493 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14494 bool result;
14495 void *argp1 = 0 ;
14496 int res1 = 0 ;
14497 PyObject *swig_obj[1] ;
14498
14499 if (!args) SWIG_fail;
14500 swig_obj[0] = args;
14501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14502 if (!SWIG_IsOK(res1)) {
14503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14504 }
14505 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14506 {
14507 PyThreadState* __tstate = wxPyBeginAllowThreads();
14508 result = (bool)(arg1)->IsRedirected();
14509 wxPyEndAllowThreads(__tstate);
14510 if (PyErr_Occurred()) SWIG_fail;
14511 }
14512 {
14513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14514 }
14515 return resultobj;
14516 fail:
14517 return NULL;
14518 }
14519
14520
14521 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14522 PyObject *resultobj = 0;
14523 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14524 void *argp1 = 0 ;
14525 int res1 = 0 ;
14526 PyObject *swig_obj[1] ;
14527
14528 if (!args) SWIG_fail;
14529 swig_obj[0] = args;
14530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14531 if (!SWIG_IsOK(res1)) {
14532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14533 }
14534 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14535 {
14536 PyThreadState* __tstate = wxPyBeginAllowThreads();
14537 (arg1)->Detach();
14538 wxPyEndAllowThreads(__tstate);
14539 if (PyErr_Occurred()) SWIG_fail;
14540 }
14541 resultobj = SWIG_Py_Void();
14542 return resultobj;
14543 fail:
14544 return NULL;
14545 }
14546
14547
14548 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14549 PyObject *resultobj = 0;
14550 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14551 wxInputStream *result = 0 ;
14552 void *argp1 = 0 ;
14553 int res1 = 0 ;
14554 PyObject *swig_obj[1] ;
14555
14556 if (!args) SWIG_fail;
14557 swig_obj[0] = args;
14558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14559 if (!SWIG_IsOK(res1)) {
14560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14561 }
14562 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 result = (wxInputStream *)(arg1)->GetInputStream();
14566 wxPyEndAllowThreads(__tstate);
14567 if (PyErr_Occurred()) SWIG_fail;
14568 }
14569 {
14570 wxPyInputStream * _ptr = NULL;
14571
14572 if (result) {
14573 _ptr = new wxPyInputStream(result);
14574 }
14575 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14576 }
14577 return resultobj;
14578 fail:
14579 return NULL;
14580 }
14581
14582
14583 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14584 PyObject *resultobj = 0;
14585 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14586 wxInputStream *result = 0 ;
14587 void *argp1 = 0 ;
14588 int res1 = 0 ;
14589 PyObject *swig_obj[1] ;
14590
14591 if (!args) SWIG_fail;
14592 swig_obj[0] = args;
14593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14594 if (!SWIG_IsOK(res1)) {
14595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14596 }
14597 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14598 {
14599 PyThreadState* __tstate = wxPyBeginAllowThreads();
14600 result = (wxInputStream *)(arg1)->GetErrorStream();
14601 wxPyEndAllowThreads(__tstate);
14602 if (PyErr_Occurred()) SWIG_fail;
14603 }
14604 {
14605 wxPyInputStream * _ptr = NULL;
14606
14607 if (result) {
14608 _ptr = new wxPyInputStream(result);
14609 }
14610 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14611 }
14612 return resultobj;
14613 fail:
14614 return NULL;
14615 }
14616
14617
14618 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14619 PyObject *resultobj = 0;
14620 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14621 wxOutputStream *result = 0 ;
14622 void *argp1 = 0 ;
14623 int res1 = 0 ;
14624 PyObject *swig_obj[1] ;
14625
14626 if (!args) SWIG_fail;
14627 swig_obj[0] = args;
14628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14629 if (!SWIG_IsOK(res1)) {
14630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14631 }
14632 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14633 {
14634 PyThreadState* __tstate = wxPyBeginAllowThreads();
14635 result = (wxOutputStream *)(arg1)->GetOutputStream();
14636 wxPyEndAllowThreads(__tstate);
14637 if (PyErr_Occurred()) SWIG_fail;
14638 }
14639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14640 return resultobj;
14641 fail:
14642 return NULL;
14643 }
14644
14645
14646 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14647 PyObject *resultobj = 0;
14648 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14649 void *argp1 = 0 ;
14650 int res1 = 0 ;
14651 PyObject *swig_obj[1] ;
14652
14653 if (!args) SWIG_fail;
14654 swig_obj[0] = args;
14655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14656 if (!SWIG_IsOK(res1)) {
14657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14658 }
14659 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14660 {
14661 PyThreadState* __tstate = wxPyBeginAllowThreads();
14662 (arg1)->CloseOutput();
14663 wxPyEndAllowThreads(__tstate);
14664 if (PyErr_Occurred()) SWIG_fail;
14665 }
14666 resultobj = SWIG_Py_Void();
14667 return resultobj;
14668 fail:
14669 return NULL;
14670 }
14671
14672
14673 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14674 PyObject *resultobj = 0;
14675 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14676 bool result;
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_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14686 }
14687 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14688 {
14689 PyThreadState* __tstate = wxPyBeginAllowThreads();
14690 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14691 wxPyEndAllowThreads(__tstate);
14692 if (PyErr_Occurred()) SWIG_fail;
14693 }
14694 {
14695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14696 }
14697 return resultobj;
14698 fail:
14699 return NULL;
14700 }
14701
14702
14703 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14704 PyObject *resultobj = 0;
14705 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14706 bool result;
14707 void *argp1 = 0 ;
14708 int res1 = 0 ;
14709 PyObject *swig_obj[1] ;
14710
14711 if (!args) SWIG_fail;
14712 swig_obj[0] = args;
14713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14714 if (!SWIG_IsOK(res1)) {
14715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14716 }
14717 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 {
14725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14726 }
14727 return resultobj;
14728 fail:
14729 return NULL;
14730 }
14731
14732
14733 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14734 PyObject *resultobj = 0;
14735 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14736 bool result;
14737 void *argp1 = 0 ;
14738 int res1 = 0 ;
14739 PyObject *swig_obj[1] ;
14740
14741 if (!args) SWIG_fail;
14742 swig_obj[0] = args;
14743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14744 if (!SWIG_IsOK(res1)) {
14745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14746 }
14747 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14748 {
14749 PyThreadState* __tstate = wxPyBeginAllowThreads();
14750 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14751 wxPyEndAllowThreads(__tstate);
14752 if (PyErr_Occurred()) SWIG_fail;
14753 }
14754 {
14755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14756 }
14757 return resultobj;
14758 fail:
14759 return NULL;
14760 }
14761
14762
14763 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14764 PyObject *obj;
14765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14766 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14767 return SWIG_Py_Void();
14768 }
14769
14770 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14771 return SWIG_Python_InitShadowInstance(args);
14772 }
14773
14774 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14775 PyObject *resultobj = 0;
14776 int arg1 = (int) 0 ;
14777 int arg2 = (int) 0 ;
14778 int arg3 = (int) 0 ;
14779 wxProcessEvent *result = 0 ;
14780 int val1 ;
14781 int ecode1 = 0 ;
14782 int val2 ;
14783 int ecode2 = 0 ;
14784 int val3 ;
14785 int ecode3 = 0 ;
14786 PyObject * obj0 = 0 ;
14787 PyObject * obj1 = 0 ;
14788 PyObject * obj2 = 0 ;
14789 char * kwnames[] = {
14790 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14791 };
14792
14793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14794 if (obj0) {
14795 ecode1 = SWIG_AsVal_int(obj0, &val1);
14796 if (!SWIG_IsOK(ecode1)) {
14797 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14798 }
14799 arg1 = static_cast< int >(val1);
14800 }
14801 if (obj1) {
14802 ecode2 = SWIG_AsVal_int(obj1, &val2);
14803 if (!SWIG_IsOK(ecode2)) {
14804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14805 }
14806 arg2 = static_cast< int >(val2);
14807 }
14808 if (obj2) {
14809 ecode3 = SWIG_AsVal_int(obj2, &val3);
14810 if (!SWIG_IsOK(ecode3)) {
14811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14812 }
14813 arg3 = static_cast< int >(val3);
14814 }
14815 {
14816 PyThreadState* __tstate = wxPyBeginAllowThreads();
14817 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14818 wxPyEndAllowThreads(__tstate);
14819 if (PyErr_Occurred()) SWIG_fail;
14820 }
14821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14822 return resultobj;
14823 fail:
14824 return NULL;
14825 }
14826
14827
14828 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14829 PyObject *resultobj = 0;
14830 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14831 int result;
14832 void *argp1 = 0 ;
14833 int res1 = 0 ;
14834 PyObject *swig_obj[1] ;
14835
14836 if (!args) SWIG_fail;
14837 swig_obj[0] = args;
14838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14839 if (!SWIG_IsOK(res1)) {
14840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14841 }
14842 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14843 {
14844 PyThreadState* __tstate = wxPyBeginAllowThreads();
14845 result = (int)(arg1)->GetPid();
14846 wxPyEndAllowThreads(__tstate);
14847 if (PyErr_Occurred()) SWIG_fail;
14848 }
14849 resultobj = SWIG_From_int(static_cast< int >(result));
14850 return resultobj;
14851 fail:
14852 return NULL;
14853 }
14854
14855
14856 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14857 PyObject *resultobj = 0;
14858 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14859 int result;
14860 void *argp1 = 0 ;
14861 int res1 = 0 ;
14862 PyObject *swig_obj[1] ;
14863
14864 if (!args) SWIG_fail;
14865 swig_obj[0] = args;
14866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14867 if (!SWIG_IsOK(res1)) {
14868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14869 }
14870 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14871 {
14872 PyThreadState* __tstate = wxPyBeginAllowThreads();
14873 result = (int)(arg1)->GetExitCode();
14874 wxPyEndAllowThreads(__tstate);
14875 if (PyErr_Occurred()) SWIG_fail;
14876 }
14877 resultobj = SWIG_From_int(static_cast< int >(result));
14878 return resultobj;
14879 fail:
14880 return NULL;
14881 }
14882
14883
14884 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14885 PyObject *resultobj = 0;
14886 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14887 int arg2 ;
14888 void *argp1 = 0 ;
14889 int res1 = 0 ;
14890 int val2 ;
14891 int ecode2 = 0 ;
14892 PyObject *swig_obj[2] ;
14893
14894 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14896 if (!SWIG_IsOK(res1)) {
14897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14898 }
14899 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14900 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14901 if (!SWIG_IsOK(ecode2)) {
14902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14903 }
14904 arg2 = static_cast< int >(val2);
14905 if (arg1) (arg1)->m_pid = arg2;
14906
14907 resultobj = SWIG_Py_Void();
14908 return resultobj;
14909 fail:
14910 return NULL;
14911 }
14912
14913
14914 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14915 PyObject *resultobj = 0;
14916 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14917 int result;
14918 void *argp1 = 0 ;
14919 int res1 = 0 ;
14920 PyObject *swig_obj[1] ;
14921
14922 if (!args) SWIG_fail;
14923 swig_obj[0] = args;
14924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14925 if (!SWIG_IsOK(res1)) {
14926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14927 }
14928 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14929 result = (int) ((arg1)->m_pid);
14930 resultobj = SWIG_From_int(static_cast< int >(result));
14931 return resultobj;
14932 fail:
14933 return NULL;
14934 }
14935
14936
14937 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14938 PyObject *resultobj = 0;
14939 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14940 int arg2 ;
14941 void *argp1 = 0 ;
14942 int res1 = 0 ;
14943 int val2 ;
14944 int ecode2 = 0 ;
14945 PyObject *swig_obj[2] ;
14946
14947 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
14948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14949 if (!SWIG_IsOK(res1)) {
14950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14951 }
14952 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14953 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14954 if (!SWIG_IsOK(ecode2)) {
14955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
14956 }
14957 arg2 = static_cast< int >(val2);
14958 if (arg1) (arg1)->m_exitcode = arg2;
14959
14960 resultobj = SWIG_Py_Void();
14961 return resultobj;
14962 fail:
14963 return NULL;
14964 }
14965
14966
14967 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14968 PyObject *resultobj = 0;
14969 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14970 int result;
14971 void *argp1 = 0 ;
14972 int res1 = 0 ;
14973 PyObject *swig_obj[1] ;
14974
14975 if (!args) SWIG_fail;
14976 swig_obj[0] = args;
14977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14978 if (!SWIG_IsOK(res1)) {
14979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14980 }
14981 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14982 result = (int) ((arg1)->m_exitcode);
14983 resultobj = SWIG_From_int(static_cast< int >(result));
14984 return resultobj;
14985 fail:
14986 return NULL;
14987 }
14988
14989
14990 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14991 PyObject *obj;
14992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14993 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
14994 return SWIG_Py_Void();
14995 }
14996
14997 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14998 return SWIG_Python_InitShadowInstance(args);
14999 }
15000
15001 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj = 0;
15003 wxString *arg1 = 0 ;
15004 int arg2 = (int) wxEXEC_ASYNC ;
15005 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15006 long result;
15007 bool temp1 = false ;
15008 int val2 ;
15009 int ecode2 = 0 ;
15010 void *argp3 = 0 ;
15011 int res3 = 0 ;
15012 PyObject * obj0 = 0 ;
15013 PyObject * obj1 = 0 ;
15014 PyObject * obj2 = 0 ;
15015 char * kwnames[] = {
15016 (char *) "command",(char *) "flags",(char *) "process", NULL
15017 };
15018
15019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15020 {
15021 arg1 = wxString_in_helper(obj0);
15022 if (arg1 == NULL) SWIG_fail;
15023 temp1 = true;
15024 }
15025 if (obj1) {
15026 ecode2 = SWIG_AsVal_int(obj1, &val2);
15027 if (!SWIG_IsOK(ecode2)) {
15028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15029 }
15030 arg2 = static_cast< int >(val2);
15031 }
15032 if (obj2) {
15033 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15034 if (!SWIG_IsOK(res3)) {
15035 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15036 }
15037 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15038 }
15039 {
15040 if (!wxPyCheckForApp()) SWIG_fail;
15041 PyThreadState* __tstate = wxPyBeginAllowThreads();
15042 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 resultobj = SWIG_From_long(static_cast< long >(result));
15047 {
15048 if (temp1)
15049 delete arg1;
15050 }
15051 return resultobj;
15052 fail:
15053 {
15054 if (temp1)
15055 delete arg1;
15056 }
15057 return NULL;
15058 }
15059
15060
15061 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15062 PyObject *resultobj = 0;
15063 long arg1 ;
15064 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15065 wxKillError *arg3 = (wxKillError *) 0 ;
15066 int arg4 = (int) wxKILL_NOCHILDREN ;
15067 int result;
15068 long val1 ;
15069 int ecode1 = 0 ;
15070 int val2 ;
15071 int ecode2 = 0 ;
15072 wxKillError temp3 ;
15073 int val4 ;
15074 int ecode4 = 0 ;
15075 PyObject * obj0 = 0 ;
15076 PyObject * obj1 = 0 ;
15077 PyObject * obj2 = 0 ;
15078 char * kwnames[] = {
15079 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15080 };
15081
15082 {
15083 arg3 = &temp3;
15084 }
15085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15086 ecode1 = SWIG_AsVal_long(obj0, &val1);
15087 if (!SWIG_IsOK(ecode1)) {
15088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15089 }
15090 arg1 = static_cast< long >(val1);
15091 if (obj1) {
15092 ecode2 = SWIG_AsVal_int(obj1, &val2);
15093 if (!SWIG_IsOK(ecode2)) {
15094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15095 }
15096 arg2 = static_cast< wxSignal >(val2);
15097 }
15098 if (obj2) {
15099 ecode4 = SWIG_AsVal_int(obj2, &val4);
15100 if (!SWIG_IsOK(ecode4)) {
15101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15102 }
15103 arg4 = static_cast< int >(val4);
15104 }
15105 {
15106 PyThreadState* __tstate = wxPyBeginAllowThreads();
15107 result = (int)wxKill(arg1,arg2,arg3,arg4);
15108 wxPyEndAllowThreads(__tstate);
15109 if (PyErr_Occurred()) SWIG_fail;
15110 }
15111 resultobj = SWIG_From_int(static_cast< int >(result));
15112 {
15113 PyObject* o;
15114 o = PyInt_FromLong((long) (*arg3));
15115
15116
15117
15118 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15119
15120 }
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15128 PyObject *resultobj = 0;
15129 int arg1 = (int) wxJOYSTICK1 ;
15130 wxJoystick *result = 0 ;
15131 int val1 ;
15132 int ecode1 = 0 ;
15133 PyObject * obj0 = 0 ;
15134 char * kwnames[] = {
15135 (char *) "joystick", NULL
15136 };
15137
15138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15139 if (obj0) {
15140 ecode1 = SWIG_AsVal_int(obj0, &val1);
15141 if (!SWIG_IsOK(ecode1)) {
15142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15143 }
15144 arg1 = static_cast< int >(val1);
15145 }
15146 {
15147 if (!wxPyCheckForApp()) SWIG_fail;
15148 PyThreadState* __tstate = wxPyBeginAllowThreads();
15149 result = (wxJoystick *)new wxJoystick(arg1);
15150 wxPyEndAllowThreads(__tstate);
15151 if (PyErr_Occurred()) SWIG_fail;
15152 }
15153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15154 return resultobj;
15155 fail:
15156 return NULL;
15157 }
15158
15159
15160 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15161 PyObject *resultobj = 0;
15162 wxJoystick *arg1 = (wxJoystick *) 0 ;
15163 void *argp1 = 0 ;
15164 int res1 = 0 ;
15165 PyObject *swig_obj[1] ;
15166
15167 if (!args) SWIG_fail;
15168 swig_obj[0] = args;
15169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15170 if (!SWIG_IsOK(res1)) {
15171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15172 }
15173 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15174 {
15175 PyThreadState* __tstate = wxPyBeginAllowThreads();
15176 delete arg1;
15177
15178 wxPyEndAllowThreads(__tstate);
15179 if (PyErr_Occurred()) SWIG_fail;
15180 }
15181 resultobj = SWIG_Py_Void();
15182 return resultobj;
15183 fail:
15184 return NULL;
15185 }
15186
15187
15188 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15189 PyObject *resultobj = 0;
15190 wxJoystick *arg1 = (wxJoystick *) 0 ;
15191 wxPoint result;
15192 void *argp1 = 0 ;
15193 int res1 = 0 ;
15194 PyObject *swig_obj[1] ;
15195
15196 if (!args) SWIG_fail;
15197 swig_obj[0] = args;
15198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15199 if (!SWIG_IsOK(res1)) {
15200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15201 }
15202 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15203 {
15204 PyThreadState* __tstate = wxPyBeginAllowThreads();
15205 result = (arg1)->GetPosition();
15206 wxPyEndAllowThreads(__tstate);
15207 if (PyErr_Occurred()) SWIG_fail;
15208 }
15209 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15210 return resultobj;
15211 fail:
15212 return NULL;
15213 }
15214
15215
15216 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15217 PyObject *resultobj = 0;
15218 wxJoystick *arg1 = (wxJoystick *) 0 ;
15219 int result;
15220 void *argp1 = 0 ;
15221 int res1 = 0 ;
15222 PyObject *swig_obj[1] ;
15223
15224 if (!args) SWIG_fail;
15225 swig_obj[0] = args;
15226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15227 if (!SWIG_IsOK(res1)) {
15228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15229 }
15230 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15231 {
15232 PyThreadState* __tstate = wxPyBeginAllowThreads();
15233 result = (int)(arg1)->GetZPosition();
15234 wxPyEndAllowThreads(__tstate);
15235 if (PyErr_Occurred()) SWIG_fail;
15236 }
15237 resultobj = SWIG_From_int(static_cast< int >(result));
15238 return resultobj;
15239 fail:
15240 return NULL;
15241 }
15242
15243
15244 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15245 PyObject *resultobj = 0;
15246 wxJoystick *arg1 = (wxJoystick *) 0 ;
15247 int result;
15248 void *argp1 = 0 ;
15249 int res1 = 0 ;
15250 PyObject *swig_obj[1] ;
15251
15252 if (!args) SWIG_fail;
15253 swig_obj[0] = args;
15254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15255 if (!SWIG_IsOK(res1)) {
15256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15257 }
15258 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15259 {
15260 PyThreadState* __tstate = wxPyBeginAllowThreads();
15261 result = (int)(arg1)->GetButtonState();
15262 wxPyEndAllowThreads(__tstate);
15263 if (PyErr_Occurred()) SWIG_fail;
15264 }
15265 resultobj = SWIG_From_int(static_cast< int >(result));
15266 return resultobj;
15267 fail:
15268 return NULL;
15269 }
15270
15271
15272 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15273 PyObject *resultobj = 0;
15274 wxJoystick *arg1 = (wxJoystick *) 0 ;
15275 int result;
15276 void *argp1 = 0 ;
15277 int res1 = 0 ;
15278 PyObject *swig_obj[1] ;
15279
15280 if (!args) SWIG_fail;
15281 swig_obj[0] = args;
15282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15283 if (!SWIG_IsOK(res1)) {
15284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15285 }
15286 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (int)(arg1)->GetPOVPosition();
15290 wxPyEndAllowThreads(__tstate);
15291 if (PyErr_Occurred()) SWIG_fail;
15292 }
15293 resultobj = SWIG_From_int(static_cast< int >(result));
15294 return resultobj;
15295 fail:
15296 return NULL;
15297 }
15298
15299
15300 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15301 PyObject *resultobj = 0;
15302 wxJoystick *arg1 = (wxJoystick *) 0 ;
15303 int result;
15304 void *argp1 = 0 ;
15305 int res1 = 0 ;
15306 PyObject *swig_obj[1] ;
15307
15308 if (!args) SWIG_fail;
15309 swig_obj[0] = args;
15310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15311 if (!SWIG_IsOK(res1)) {
15312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15313 }
15314 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15315 {
15316 PyThreadState* __tstate = wxPyBeginAllowThreads();
15317 result = (int)(arg1)->GetPOVCTSPosition();
15318 wxPyEndAllowThreads(__tstate);
15319 if (PyErr_Occurred()) SWIG_fail;
15320 }
15321 resultobj = SWIG_From_int(static_cast< int >(result));
15322 return resultobj;
15323 fail:
15324 return NULL;
15325 }
15326
15327
15328 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15329 PyObject *resultobj = 0;
15330 wxJoystick *arg1 = (wxJoystick *) 0 ;
15331 int result;
15332 void *argp1 = 0 ;
15333 int res1 = 0 ;
15334 PyObject *swig_obj[1] ;
15335
15336 if (!args) SWIG_fail;
15337 swig_obj[0] = args;
15338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15339 if (!SWIG_IsOK(res1)) {
15340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15341 }
15342 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 result = (int)(arg1)->GetRudderPosition();
15346 wxPyEndAllowThreads(__tstate);
15347 if (PyErr_Occurred()) SWIG_fail;
15348 }
15349 resultobj = SWIG_From_int(static_cast< int >(result));
15350 return resultobj;
15351 fail:
15352 return NULL;
15353 }
15354
15355
15356 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15357 PyObject *resultobj = 0;
15358 wxJoystick *arg1 = (wxJoystick *) 0 ;
15359 int result;
15360 void *argp1 = 0 ;
15361 int res1 = 0 ;
15362 PyObject *swig_obj[1] ;
15363
15364 if (!args) SWIG_fail;
15365 swig_obj[0] = args;
15366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15367 if (!SWIG_IsOK(res1)) {
15368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15369 }
15370 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15371 {
15372 PyThreadState* __tstate = wxPyBeginAllowThreads();
15373 result = (int)(arg1)->GetUPosition();
15374 wxPyEndAllowThreads(__tstate);
15375 if (PyErr_Occurred()) SWIG_fail;
15376 }
15377 resultobj = SWIG_From_int(static_cast< int >(result));
15378 return resultobj;
15379 fail:
15380 return NULL;
15381 }
15382
15383
15384 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15385 PyObject *resultobj = 0;
15386 wxJoystick *arg1 = (wxJoystick *) 0 ;
15387 int result;
15388 void *argp1 = 0 ;
15389 int res1 = 0 ;
15390 PyObject *swig_obj[1] ;
15391
15392 if (!args) SWIG_fail;
15393 swig_obj[0] = args;
15394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15395 if (!SWIG_IsOK(res1)) {
15396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15397 }
15398 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15399 {
15400 PyThreadState* __tstate = wxPyBeginAllowThreads();
15401 result = (int)(arg1)->GetVPosition();
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 resultobj = SWIG_From_int(static_cast< int >(result));
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15413 PyObject *resultobj = 0;
15414 wxJoystick *arg1 = (wxJoystick *) 0 ;
15415 int result;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 PyObject *swig_obj[1] ;
15419
15420 if (!args) SWIG_fail;
15421 swig_obj[0] = args;
15422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15423 if (!SWIG_IsOK(res1)) {
15424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15425 }
15426 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 result = (int)(arg1)->GetMovementThreshold();
15430 wxPyEndAllowThreads(__tstate);
15431 if (PyErr_Occurred()) SWIG_fail;
15432 }
15433 resultobj = SWIG_From_int(static_cast< int >(result));
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15441 PyObject *resultobj = 0;
15442 wxJoystick *arg1 = (wxJoystick *) 0 ;
15443 int arg2 ;
15444 void *argp1 = 0 ;
15445 int res1 = 0 ;
15446 int val2 ;
15447 int ecode2 = 0 ;
15448 PyObject * obj0 = 0 ;
15449 PyObject * obj1 = 0 ;
15450 char * kwnames[] = {
15451 (char *) "self",(char *) "threshold", NULL
15452 };
15453
15454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15456 if (!SWIG_IsOK(res1)) {
15457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15458 }
15459 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15460 ecode2 = SWIG_AsVal_int(obj1, &val2);
15461 if (!SWIG_IsOK(ecode2)) {
15462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15463 }
15464 arg2 = static_cast< int >(val2);
15465 {
15466 PyThreadState* __tstate = wxPyBeginAllowThreads();
15467 (arg1)->SetMovementThreshold(arg2);
15468 wxPyEndAllowThreads(__tstate);
15469 if (PyErr_Occurred()) SWIG_fail;
15470 }
15471 resultobj = SWIG_Py_Void();
15472 return resultobj;
15473 fail:
15474 return NULL;
15475 }
15476
15477
15478 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15479 PyObject *resultobj = 0;
15480 wxJoystick *arg1 = (wxJoystick *) 0 ;
15481 bool result;
15482 void *argp1 = 0 ;
15483 int res1 = 0 ;
15484 PyObject *swig_obj[1] ;
15485
15486 if (!args) SWIG_fail;
15487 swig_obj[0] = args;
15488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15489 if (!SWIG_IsOK(res1)) {
15490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15491 }
15492 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15493 {
15494 PyThreadState* __tstate = wxPyBeginAllowThreads();
15495 result = (bool)(arg1)->IsOk();
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 {
15500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15501 }
15502 return resultobj;
15503 fail:
15504 return NULL;
15505 }
15506
15507
15508 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15509 PyObject *resultobj = 0;
15510 wxJoystick *arg1 = (wxJoystick *) 0 ;
15511 int result;
15512 void *argp1 = 0 ;
15513 int res1 = 0 ;
15514 PyObject *swig_obj[1] ;
15515
15516 if (!args) SWIG_fail;
15517 swig_obj[0] = args;
15518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15519 if (!SWIG_IsOK(res1)) {
15520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15521 }
15522 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 result = (int)(arg1)->GetNumberJoysticks();
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 resultobj = SWIG_From_int(static_cast< int >(result));
15530 return resultobj;
15531 fail:
15532 return NULL;
15533 }
15534
15535
15536 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15537 PyObject *resultobj = 0;
15538 wxJoystick *arg1 = (wxJoystick *) 0 ;
15539 int result;
15540 void *argp1 = 0 ;
15541 int res1 = 0 ;
15542 PyObject *swig_obj[1] ;
15543
15544 if (!args) SWIG_fail;
15545 swig_obj[0] = args;
15546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15547 if (!SWIG_IsOK(res1)) {
15548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15549 }
15550 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15551 {
15552 PyThreadState* __tstate = wxPyBeginAllowThreads();
15553 result = (int)(arg1)->GetManufacturerId();
15554 wxPyEndAllowThreads(__tstate);
15555 if (PyErr_Occurred()) SWIG_fail;
15556 }
15557 resultobj = SWIG_From_int(static_cast< int >(result));
15558 return resultobj;
15559 fail:
15560 return NULL;
15561 }
15562
15563
15564 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15565 PyObject *resultobj = 0;
15566 wxJoystick *arg1 = (wxJoystick *) 0 ;
15567 int result;
15568 void *argp1 = 0 ;
15569 int res1 = 0 ;
15570 PyObject *swig_obj[1] ;
15571
15572 if (!args) SWIG_fail;
15573 swig_obj[0] = args;
15574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15575 if (!SWIG_IsOK(res1)) {
15576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15577 }
15578 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 result = (int)(arg1)->GetProductId();
15582 wxPyEndAllowThreads(__tstate);
15583 if (PyErr_Occurred()) SWIG_fail;
15584 }
15585 resultobj = SWIG_From_int(static_cast< int >(result));
15586 return resultobj;
15587 fail:
15588 return NULL;
15589 }
15590
15591
15592 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15593 PyObject *resultobj = 0;
15594 wxJoystick *arg1 = (wxJoystick *) 0 ;
15595 wxString result;
15596 void *argp1 = 0 ;
15597 int res1 = 0 ;
15598 PyObject *swig_obj[1] ;
15599
15600 if (!args) SWIG_fail;
15601 swig_obj[0] = args;
15602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15603 if (!SWIG_IsOK(res1)) {
15604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15605 }
15606 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15607 {
15608 PyThreadState* __tstate = wxPyBeginAllowThreads();
15609 result = (arg1)->GetProductName();
15610 wxPyEndAllowThreads(__tstate);
15611 if (PyErr_Occurred()) SWIG_fail;
15612 }
15613 {
15614 #if wxUSE_UNICODE
15615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15616 #else
15617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15618 #endif
15619 }
15620 return resultobj;
15621 fail:
15622 return NULL;
15623 }
15624
15625
15626 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15627 PyObject *resultobj = 0;
15628 wxJoystick *arg1 = (wxJoystick *) 0 ;
15629 int result;
15630 void *argp1 = 0 ;
15631 int res1 = 0 ;
15632 PyObject *swig_obj[1] ;
15633
15634 if (!args) SWIG_fail;
15635 swig_obj[0] = args;
15636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15637 if (!SWIG_IsOK(res1)) {
15638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15639 }
15640 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15641 {
15642 PyThreadState* __tstate = wxPyBeginAllowThreads();
15643 result = (int)(arg1)->GetXMin();
15644 wxPyEndAllowThreads(__tstate);
15645 if (PyErr_Occurred()) SWIG_fail;
15646 }
15647 resultobj = SWIG_From_int(static_cast< int >(result));
15648 return resultobj;
15649 fail:
15650 return NULL;
15651 }
15652
15653
15654 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15655 PyObject *resultobj = 0;
15656 wxJoystick *arg1 = (wxJoystick *) 0 ;
15657 int result;
15658 void *argp1 = 0 ;
15659 int res1 = 0 ;
15660 PyObject *swig_obj[1] ;
15661
15662 if (!args) SWIG_fail;
15663 swig_obj[0] = args;
15664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15665 if (!SWIG_IsOK(res1)) {
15666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15667 }
15668 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15669 {
15670 PyThreadState* __tstate = wxPyBeginAllowThreads();
15671 result = (int)(arg1)->GetYMin();
15672 wxPyEndAllowThreads(__tstate);
15673 if (PyErr_Occurred()) SWIG_fail;
15674 }
15675 resultobj = SWIG_From_int(static_cast< int >(result));
15676 return resultobj;
15677 fail:
15678 return NULL;
15679 }
15680
15681
15682 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15683 PyObject *resultobj = 0;
15684 wxJoystick *arg1 = (wxJoystick *) 0 ;
15685 int result;
15686 void *argp1 = 0 ;
15687 int res1 = 0 ;
15688 PyObject *swig_obj[1] ;
15689
15690 if (!args) SWIG_fail;
15691 swig_obj[0] = args;
15692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15693 if (!SWIG_IsOK(res1)) {
15694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15695 }
15696 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15697 {
15698 PyThreadState* __tstate = wxPyBeginAllowThreads();
15699 result = (int)(arg1)->GetZMin();
15700 wxPyEndAllowThreads(__tstate);
15701 if (PyErr_Occurred()) SWIG_fail;
15702 }
15703 resultobj = SWIG_From_int(static_cast< int >(result));
15704 return resultobj;
15705 fail:
15706 return NULL;
15707 }
15708
15709
15710 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15711 PyObject *resultobj = 0;
15712 wxJoystick *arg1 = (wxJoystick *) 0 ;
15713 int result;
15714 void *argp1 = 0 ;
15715 int res1 = 0 ;
15716 PyObject *swig_obj[1] ;
15717
15718 if (!args) SWIG_fail;
15719 swig_obj[0] = args;
15720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15721 if (!SWIG_IsOK(res1)) {
15722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15723 }
15724 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15725 {
15726 PyThreadState* __tstate = wxPyBeginAllowThreads();
15727 result = (int)(arg1)->GetXMax();
15728 wxPyEndAllowThreads(__tstate);
15729 if (PyErr_Occurred()) SWIG_fail;
15730 }
15731 resultobj = SWIG_From_int(static_cast< int >(result));
15732 return resultobj;
15733 fail:
15734 return NULL;
15735 }
15736
15737
15738 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15739 PyObject *resultobj = 0;
15740 wxJoystick *arg1 = (wxJoystick *) 0 ;
15741 int result;
15742 void *argp1 = 0 ;
15743 int res1 = 0 ;
15744 PyObject *swig_obj[1] ;
15745
15746 if (!args) SWIG_fail;
15747 swig_obj[0] = args;
15748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15749 if (!SWIG_IsOK(res1)) {
15750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15751 }
15752 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15753 {
15754 PyThreadState* __tstate = wxPyBeginAllowThreads();
15755 result = (int)(arg1)->GetYMax();
15756 wxPyEndAllowThreads(__tstate);
15757 if (PyErr_Occurred()) SWIG_fail;
15758 }
15759 resultobj = SWIG_From_int(static_cast< int >(result));
15760 return resultobj;
15761 fail:
15762 return NULL;
15763 }
15764
15765
15766 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15767 PyObject *resultobj = 0;
15768 wxJoystick *arg1 = (wxJoystick *) 0 ;
15769 int result;
15770 void *argp1 = 0 ;
15771 int res1 = 0 ;
15772 PyObject *swig_obj[1] ;
15773
15774 if (!args) SWIG_fail;
15775 swig_obj[0] = args;
15776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15777 if (!SWIG_IsOK(res1)) {
15778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15779 }
15780 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15781 {
15782 PyThreadState* __tstate = wxPyBeginAllowThreads();
15783 result = (int)(arg1)->GetZMax();
15784 wxPyEndAllowThreads(__tstate);
15785 if (PyErr_Occurred()) SWIG_fail;
15786 }
15787 resultobj = SWIG_From_int(static_cast< int >(result));
15788 return resultobj;
15789 fail:
15790 return NULL;
15791 }
15792
15793
15794 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15795 PyObject *resultobj = 0;
15796 wxJoystick *arg1 = (wxJoystick *) 0 ;
15797 int result;
15798 void *argp1 = 0 ;
15799 int res1 = 0 ;
15800 PyObject *swig_obj[1] ;
15801
15802 if (!args) SWIG_fail;
15803 swig_obj[0] = args;
15804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15805 if (!SWIG_IsOK(res1)) {
15806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15807 }
15808 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15809 {
15810 PyThreadState* __tstate = wxPyBeginAllowThreads();
15811 result = (int)(arg1)->GetNumberButtons();
15812 wxPyEndAllowThreads(__tstate);
15813 if (PyErr_Occurred()) SWIG_fail;
15814 }
15815 resultobj = SWIG_From_int(static_cast< int >(result));
15816 return resultobj;
15817 fail:
15818 return NULL;
15819 }
15820
15821
15822 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15823 PyObject *resultobj = 0;
15824 wxJoystick *arg1 = (wxJoystick *) 0 ;
15825 int result;
15826 void *argp1 = 0 ;
15827 int res1 = 0 ;
15828 PyObject *swig_obj[1] ;
15829
15830 if (!args) SWIG_fail;
15831 swig_obj[0] = args;
15832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15833 if (!SWIG_IsOK(res1)) {
15834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15835 }
15836 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15837 {
15838 PyThreadState* __tstate = wxPyBeginAllowThreads();
15839 result = (int)(arg1)->GetNumberAxes();
15840 wxPyEndAllowThreads(__tstate);
15841 if (PyErr_Occurred()) SWIG_fail;
15842 }
15843 resultobj = SWIG_From_int(static_cast< int >(result));
15844 return resultobj;
15845 fail:
15846 return NULL;
15847 }
15848
15849
15850 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15851 PyObject *resultobj = 0;
15852 wxJoystick *arg1 = (wxJoystick *) 0 ;
15853 int result;
15854 void *argp1 = 0 ;
15855 int res1 = 0 ;
15856 PyObject *swig_obj[1] ;
15857
15858 if (!args) SWIG_fail;
15859 swig_obj[0] = args;
15860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15861 if (!SWIG_IsOK(res1)) {
15862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15863 }
15864 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15865 {
15866 PyThreadState* __tstate = wxPyBeginAllowThreads();
15867 result = (int)(arg1)->GetMaxButtons();
15868 wxPyEndAllowThreads(__tstate);
15869 if (PyErr_Occurred()) SWIG_fail;
15870 }
15871 resultobj = SWIG_From_int(static_cast< int >(result));
15872 return resultobj;
15873 fail:
15874 return NULL;
15875 }
15876
15877
15878 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15879 PyObject *resultobj = 0;
15880 wxJoystick *arg1 = (wxJoystick *) 0 ;
15881 int result;
15882 void *argp1 = 0 ;
15883 int res1 = 0 ;
15884 PyObject *swig_obj[1] ;
15885
15886 if (!args) SWIG_fail;
15887 swig_obj[0] = args;
15888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15889 if (!SWIG_IsOK(res1)) {
15890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15891 }
15892 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15893 {
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 result = (int)(arg1)->GetMaxAxes();
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 resultobj = SWIG_From_int(static_cast< int >(result));
15900 return resultobj;
15901 fail:
15902 return NULL;
15903 }
15904
15905
15906 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15907 PyObject *resultobj = 0;
15908 wxJoystick *arg1 = (wxJoystick *) 0 ;
15909 int result;
15910 void *argp1 = 0 ;
15911 int res1 = 0 ;
15912 PyObject *swig_obj[1] ;
15913
15914 if (!args) SWIG_fail;
15915 swig_obj[0] = args;
15916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15917 if (!SWIG_IsOK(res1)) {
15918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15919 }
15920 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15921 {
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 result = (int)(arg1)->GetPollingMin();
15924 wxPyEndAllowThreads(__tstate);
15925 if (PyErr_Occurred()) SWIG_fail;
15926 }
15927 resultobj = SWIG_From_int(static_cast< int >(result));
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15935 PyObject *resultobj = 0;
15936 wxJoystick *arg1 = (wxJoystick *) 0 ;
15937 int result;
15938 void *argp1 = 0 ;
15939 int res1 = 0 ;
15940 PyObject *swig_obj[1] ;
15941
15942 if (!args) SWIG_fail;
15943 swig_obj[0] = args;
15944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15945 if (!SWIG_IsOK(res1)) {
15946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15947 }
15948 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 result = (int)(arg1)->GetPollingMax();
15952 wxPyEndAllowThreads(__tstate);
15953 if (PyErr_Occurred()) SWIG_fail;
15954 }
15955 resultobj = SWIG_From_int(static_cast< int >(result));
15956 return resultobj;
15957 fail:
15958 return NULL;
15959 }
15960
15961
15962 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15963 PyObject *resultobj = 0;
15964 wxJoystick *arg1 = (wxJoystick *) 0 ;
15965 int result;
15966 void *argp1 = 0 ;
15967 int res1 = 0 ;
15968 PyObject *swig_obj[1] ;
15969
15970 if (!args) SWIG_fail;
15971 swig_obj[0] = args;
15972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15973 if (!SWIG_IsOK(res1)) {
15974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15975 }
15976 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15977 {
15978 PyThreadState* __tstate = wxPyBeginAllowThreads();
15979 result = (int)(arg1)->GetRudderMin();
15980 wxPyEndAllowThreads(__tstate);
15981 if (PyErr_Occurred()) SWIG_fail;
15982 }
15983 resultobj = SWIG_From_int(static_cast< int >(result));
15984 return resultobj;
15985 fail:
15986 return NULL;
15987 }
15988
15989
15990 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15991 PyObject *resultobj = 0;
15992 wxJoystick *arg1 = (wxJoystick *) 0 ;
15993 int result;
15994 void *argp1 = 0 ;
15995 int res1 = 0 ;
15996 PyObject *swig_obj[1] ;
15997
15998 if (!args) SWIG_fail;
15999 swig_obj[0] = args;
16000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16001 if (!SWIG_IsOK(res1)) {
16002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16003 }
16004 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16005 {
16006 PyThreadState* __tstate = wxPyBeginAllowThreads();
16007 result = (int)(arg1)->GetRudderMax();
16008 wxPyEndAllowThreads(__tstate);
16009 if (PyErr_Occurred()) SWIG_fail;
16010 }
16011 resultobj = SWIG_From_int(static_cast< int >(result));
16012 return resultobj;
16013 fail:
16014 return NULL;
16015 }
16016
16017
16018 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16019 PyObject *resultobj = 0;
16020 wxJoystick *arg1 = (wxJoystick *) 0 ;
16021 int result;
16022 void *argp1 = 0 ;
16023 int res1 = 0 ;
16024 PyObject *swig_obj[1] ;
16025
16026 if (!args) SWIG_fail;
16027 swig_obj[0] = args;
16028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16029 if (!SWIG_IsOK(res1)) {
16030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16031 }
16032 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16033 {
16034 PyThreadState* __tstate = wxPyBeginAllowThreads();
16035 result = (int)(arg1)->GetUMin();
16036 wxPyEndAllowThreads(__tstate);
16037 if (PyErr_Occurred()) SWIG_fail;
16038 }
16039 resultobj = SWIG_From_int(static_cast< int >(result));
16040 return resultobj;
16041 fail:
16042 return NULL;
16043 }
16044
16045
16046 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16047 PyObject *resultobj = 0;
16048 wxJoystick *arg1 = (wxJoystick *) 0 ;
16049 int result;
16050 void *argp1 = 0 ;
16051 int res1 = 0 ;
16052 PyObject *swig_obj[1] ;
16053
16054 if (!args) SWIG_fail;
16055 swig_obj[0] = args;
16056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16057 if (!SWIG_IsOK(res1)) {
16058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16059 }
16060 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16061 {
16062 PyThreadState* __tstate = wxPyBeginAllowThreads();
16063 result = (int)(arg1)->GetUMax();
16064 wxPyEndAllowThreads(__tstate);
16065 if (PyErr_Occurred()) SWIG_fail;
16066 }
16067 resultobj = SWIG_From_int(static_cast< int >(result));
16068 return resultobj;
16069 fail:
16070 return NULL;
16071 }
16072
16073
16074 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16075 PyObject *resultobj = 0;
16076 wxJoystick *arg1 = (wxJoystick *) 0 ;
16077 int result;
16078 void *argp1 = 0 ;
16079 int res1 = 0 ;
16080 PyObject *swig_obj[1] ;
16081
16082 if (!args) SWIG_fail;
16083 swig_obj[0] = args;
16084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16085 if (!SWIG_IsOK(res1)) {
16086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16087 }
16088 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16089 {
16090 PyThreadState* __tstate = wxPyBeginAllowThreads();
16091 result = (int)(arg1)->GetVMin();
16092 wxPyEndAllowThreads(__tstate);
16093 if (PyErr_Occurred()) SWIG_fail;
16094 }
16095 resultobj = SWIG_From_int(static_cast< int >(result));
16096 return resultobj;
16097 fail:
16098 return NULL;
16099 }
16100
16101
16102 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16103 PyObject *resultobj = 0;
16104 wxJoystick *arg1 = (wxJoystick *) 0 ;
16105 int result;
16106 void *argp1 = 0 ;
16107 int res1 = 0 ;
16108 PyObject *swig_obj[1] ;
16109
16110 if (!args) SWIG_fail;
16111 swig_obj[0] = args;
16112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16113 if (!SWIG_IsOK(res1)) {
16114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16115 }
16116 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16117 {
16118 PyThreadState* __tstate = wxPyBeginAllowThreads();
16119 result = (int)(arg1)->GetVMax();
16120 wxPyEndAllowThreads(__tstate);
16121 if (PyErr_Occurred()) SWIG_fail;
16122 }
16123 resultobj = SWIG_From_int(static_cast< int >(result));
16124 return resultobj;
16125 fail:
16126 return NULL;
16127 }
16128
16129
16130 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16131 PyObject *resultobj = 0;
16132 wxJoystick *arg1 = (wxJoystick *) 0 ;
16133 bool result;
16134 void *argp1 = 0 ;
16135 int res1 = 0 ;
16136 PyObject *swig_obj[1] ;
16137
16138 if (!args) SWIG_fail;
16139 swig_obj[0] = args;
16140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16141 if (!SWIG_IsOK(res1)) {
16142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16143 }
16144 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16145 {
16146 PyThreadState* __tstate = wxPyBeginAllowThreads();
16147 result = (bool)(arg1)->HasRudder();
16148 wxPyEndAllowThreads(__tstate);
16149 if (PyErr_Occurred()) SWIG_fail;
16150 }
16151 {
16152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16153 }
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16161 PyObject *resultobj = 0;
16162 wxJoystick *arg1 = (wxJoystick *) 0 ;
16163 bool result;
16164 void *argp1 = 0 ;
16165 int res1 = 0 ;
16166 PyObject *swig_obj[1] ;
16167
16168 if (!args) SWIG_fail;
16169 swig_obj[0] = args;
16170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16171 if (!SWIG_IsOK(res1)) {
16172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16173 }
16174 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16175 {
16176 PyThreadState* __tstate = wxPyBeginAllowThreads();
16177 result = (bool)(arg1)->HasZ();
16178 wxPyEndAllowThreads(__tstate);
16179 if (PyErr_Occurred()) SWIG_fail;
16180 }
16181 {
16182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16183 }
16184 return resultobj;
16185 fail:
16186 return NULL;
16187 }
16188
16189
16190 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16191 PyObject *resultobj = 0;
16192 wxJoystick *arg1 = (wxJoystick *) 0 ;
16193 bool result;
16194 void *argp1 = 0 ;
16195 int res1 = 0 ;
16196 PyObject *swig_obj[1] ;
16197
16198 if (!args) SWIG_fail;
16199 swig_obj[0] = args;
16200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16201 if (!SWIG_IsOK(res1)) {
16202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16203 }
16204 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16205 {
16206 PyThreadState* __tstate = wxPyBeginAllowThreads();
16207 result = (bool)(arg1)->HasU();
16208 wxPyEndAllowThreads(__tstate);
16209 if (PyErr_Occurred()) SWIG_fail;
16210 }
16211 {
16212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16213 }
16214 return resultobj;
16215 fail:
16216 return NULL;
16217 }
16218
16219
16220 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16221 PyObject *resultobj = 0;
16222 wxJoystick *arg1 = (wxJoystick *) 0 ;
16223 bool result;
16224 void *argp1 = 0 ;
16225 int res1 = 0 ;
16226 PyObject *swig_obj[1] ;
16227
16228 if (!args) SWIG_fail;
16229 swig_obj[0] = args;
16230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16231 if (!SWIG_IsOK(res1)) {
16232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16233 }
16234 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16235 {
16236 PyThreadState* __tstate = wxPyBeginAllowThreads();
16237 result = (bool)(arg1)->HasV();
16238 wxPyEndAllowThreads(__tstate);
16239 if (PyErr_Occurred()) SWIG_fail;
16240 }
16241 {
16242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16243 }
16244 return resultobj;
16245 fail:
16246 return NULL;
16247 }
16248
16249
16250 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16251 PyObject *resultobj = 0;
16252 wxJoystick *arg1 = (wxJoystick *) 0 ;
16253 bool result;
16254 void *argp1 = 0 ;
16255 int res1 = 0 ;
16256 PyObject *swig_obj[1] ;
16257
16258 if (!args) SWIG_fail;
16259 swig_obj[0] = args;
16260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16261 if (!SWIG_IsOK(res1)) {
16262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16263 }
16264 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 result = (bool)(arg1)->HasPOV();
16268 wxPyEndAllowThreads(__tstate);
16269 if (PyErr_Occurred()) SWIG_fail;
16270 }
16271 {
16272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16273 }
16274 return resultobj;
16275 fail:
16276 return NULL;
16277 }
16278
16279
16280 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16281 PyObject *resultobj = 0;
16282 wxJoystick *arg1 = (wxJoystick *) 0 ;
16283 bool result;
16284 void *argp1 = 0 ;
16285 int res1 = 0 ;
16286 PyObject *swig_obj[1] ;
16287
16288 if (!args) SWIG_fail;
16289 swig_obj[0] = args;
16290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16291 if (!SWIG_IsOK(res1)) {
16292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16293 }
16294 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16295 {
16296 PyThreadState* __tstate = wxPyBeginAllowThreads();
16297 result = (bool)(arg1)->HasPOV4Dir();
16298 wxPyEndAllowThreads(__tstate);
16299 if (PyErr_Occurred()) SWIG_fail;
16300 }
16301 {
16302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16303 }
16304 return resultobj;
16305 fail:
16306 return NULL;
16307 }
16308
16309
16310 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16311 PyObject *resultobj = 0;
16312 wxJoystick *arg1 = (wxJoystick *) 0 ;
16313 bool result;
16314 void *argp1 = 0 ;
16315 int res1 = 0 ;
16316 PyObject *swig_obj[1] ;
16317
16318 if (!args) SWIG_fail;
16319 swig_obj[0] = args;
16320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16321 if (!SWIG_IsOK(res1)) {
16322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16323 }
16324 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16325 {
16326 PyThreadState* __tstate = wxPyBeginAllowThreads();
16327 result = (bool)(arg1)->HasPOVCTS();
16328 wxPyEndAllowThreads(__tstate);
16329 if (PyErr_Occurred()) SWIG_fail;
16330 }
16331 {
16332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16333 }
16334 return resultobj;
16335 fail:
16336 return NULL;
16337 }
16338
16339
16340 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16341 PyObject *resultobj = 0;
16342 wxJoystick *arg1 = (wxJoystick *) 0 ;
16343 wxWindow *arg2 = (wxWindow *) 0 ;
16344 int arg3 = (int) 0 ;
16345 bool result;
16346 void *argp1 = 0 ;
16347 int res1 = 0 ;
16348 void *argp2 = 0 ;
16349 int res2 = 0 ;
16350 int val3 ;
16351 int ecode3 = 0 ;
16352 PyObject * obj0 = 0 ;
16353 PyObject * obj1 = 0 ;
16354 PyObject * obj2 = 0 ;
16355 char * kwnames[] = {
16356 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16357 };
16358
16359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16361 if (!SWIG_IsOK(res1)) {
16362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16363 }
16364 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16365 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16366 if (!SWIG_IsOK(res2)) {
16367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16368 }
16369 arg2 = reinterpret_cast< wxWindow * >(argp2);
16370 if (obj2) {
16371 ecode3 = SWIG_AsVal_int(obj2, &val3);
16372 if (!SWIG_IsOK(ecode3)) {
16373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16374 }
16375 arg3 = static_cast< int >(val3);
16376 }
16377 {
16378 PyThreadState* __tstate = wxPyBeginAllowThreads();
16379 result = (bool)(arg1)->SetCapture(arg2,arg3);
16380 wxPyEndAllowThreads(__tstate);
16381 if (PyErr_Occurred()) SWIG_fail;
16382 }
16383 {
16384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16385 }
16386 return resultobj;
16387 fail:
16388 return NULL;
16389 }
16390
16391
16392 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16393 PyObject *resultobj = 0;
16394 wxJoystick *arg1 = (wxJoystick *) 0 ;
16395 bool result;
16396 void *argp1 = 0 ;
16397 int res1 = 0 ;
16398 PyObject *swig_obj[1] ;
16399
16400 if (!args) SWIG_fail;
16401 swig_obj[0] = args;
16402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16403 if (!SWIG_IsOK(res1)) {
16404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16405 }
16406 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16407 {
16408 PyThreadState* __tstate = wxPyBeginAllowThreads();
16409 result = (bool)(arg1)->ReleaseCapture();
16410 wxPyEndAllowThreads(__tstate);
16411 if (PyErr_Occurred()) SWIG_fail;
16412 }
16413 {
16414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16415 }
16416 return resultobj;
16417 fail:
16418 return NULL;
16419 }
16420
16421
16422 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16423 PyObject *obj;
16424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16425 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16426 return SWIG_Py_Void();
16427 }
16428
16429 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16430 return SWIG_Python_InitShadowInstance(args);
16431 }
16432
16433 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16434 PyObject *resultobj = 0;
16435 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16436 int arg2 = (int) 0 ;
16437 int arg3 = (int) wxJOYSTICK1 ;
16438 int arg4 = (int) 0 ;
16439 wxJoystickEvent *result = 0 ;
16440 int val1 ;
16441 int ecode1 = 0 ;
16442 int val2 ;
16443 int ecode2 = 0 ;
16444 int val3 ;
16445 int ecode3 = 0 ;
16446 int val4 ;
16447 int ecode4 = 0 ;
16448 PyObject * obj0 = 0 ;
16449 PyObject * obj1 = 0 ;
16450 PyObject * obj2 = 0 ;
16451 PyObject * obj3 = 0 ;
16452 char * kwnames[] = {
16453 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16454 };
16455
16456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16457 if (obj0) {
16458 ecode1 = SWIG_AsVal_int(obj0, &val1);
16459 if (!SWIG_IsOK(ecode1)) {
16460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16461 }
16462 arg1 = static_cast< wxEventType >(val1);
16463 }
16464 if (obj1) {
16465 ecode2 = SWIG_AsVal_int(obj1, &val2);
16466 if (!SWIG_IsOK(ecode2)) {
16467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16468 }
16469 arg2 = static_cast< int >(val2);
16470 }
16471 if (obj2) {
16472 ecode3 = SWIG_AsVal_int(obj2, &val3);
16473 if (!SWIG_IsOK(ecode3)) {
16474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16475 }
16476 arg3 = static_cast< int >(val3);
16477 }
16478 if (obj3) {
16479 ecode4 = SWIG_AsVal_int(obj3, &val4);
16480 if (!SWIG_IsOK(ecode4)) {
16481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16482 }
16483 arg4 = static_cast< int >(val4);
16484 }
16485 {
16486 PyThreadState* __tstate = wxPyBeginAllowThreads();
16487 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16488 wxPyEndAllowThreads(__tstate);
16489 if (PyErr_Occurred()) SWIG_fail;
16490 }
16491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16492 return resultobj;
16493 fail:
16494 return NULL;
16495 }
16496
16497
16498 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16499 PyObject *resultobj = 0;
16500 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16501 wxPoint result;
16502 void *argp1 = 0 ;
16503 int res1 = 0 ;
16504 PyObject *swig_obj[1] ;
16505
16506 if (!args) SWIG_fail;
16507 swig_obj[0] = args;
16508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16509 if (!SWIG_IsOK(res1)) {
16510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16511 }
16512 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16513 {
16514 PyThreadState* __tstate = wxPyBeginAllowThreads();
16515 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16527 PyObject *resultobj = 0;
16528 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16529 int result;
16530 void *argp1 = 0 ;
16531 int res1 = 0 ;
16532 PyObject *swig_obj[1] ;
16533
16534 if (!args) SWIG_fail;
16535 swig_obj[0] = args;
16536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16537 if (!SWIG_IsOK(res1)) {
16538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16539 }
16540 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16541 {
16542 PyThreadState* __tstate = wxPyBeginAllowThreads();
16543 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16544 wxPyEndAllowThreads(__tstate);
16545 if (PyErr_Occurred()) SWIG_fail;
16546 }
16547 resultobj = SWIG_From_int(static_cast< int >(result));
16548 return resultobj;
16549 fail:
16550 return NULL;
16551 }
16552
16553
16554 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16555 PyObject *resultobj = 0;
16556 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16557 int result;
16558 void *argp1 = 0 ;
16559 int res1 = 0 ;
16560 PyObject *swig_obj[1] ;
16561
16562 if (!args) SWIG_fail;
16563 swig_obj[0] = args;
16564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16565 if (!SWIG_IsOK(res1)) {
16566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16567 }
16568 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16572 wxPyEndAllowThreads(__tstate);
16573 if (PyErr_Occurred()) SWIG_fail;
16574 }
16575 resultobj = SWIG_From_int(static_cast< int >(result));
16576 return resultobj;
16577 fail:
16578 return NULL;
16579 }
16580
16581
16582 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16583 PyObject *resultobj = 0;
16584 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16585 int result;
16586 void *argp1 = 0 ;
16587 int res1 = 0 ;
16588 PyObject *swig_obj[1] ;
16589
16590 if (!args) SWIG_fail;
16591 swig_obj[0] = args;
16592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16593 if (!SWIG_IsOK(res1)) {
16594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16595 }
16596 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16600 wxPyEndAllowThreads(__tstate);
16601 if (PyErr_Occurred()) SWIG_fail;
16602 }
16603 resultobj = SWIG_From_int(static_cast< int >(result));
16604 return resultobj;
16605 fail:
16606 return NULL;
16607 }
16608
16609
16610 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16611 PyObject *resultobj = 0;
16612 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16613 int result;
16614 void *argp1 = 0 ;
16615 int res1 = 0 ;
16616 PyObject *swig_obj[1] ;
16617
16618 if (!args) SWIG_fail;
16619 swig_obj[0] = args;
16620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16621 if (!SWIG_IsOK(res1)) {
16622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16623 }
16624 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16625 {
16626 PyThreadState* __tstate = wxPyBeginAllowThreads();
16627 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16628 wxPyEndAllowThreads(__tstate);
16629 if (PyErr_Occurred()) SWIG_fail;
16630 }
16631 resultobj = SWIG_From_int(static_cast< int >(result));
16632 return resultobj;
16633 fail:
16634 return NULL;
16635 }
16636
16637
16638 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16639 PyObject *resultobj = 0;
16640 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16641 int arg2 ;
16642 void *argp1 = 0 ;
16643 int res1 = 0 ;
16644 int val2 ;
16645 int ecode2 = 0 ;
16646 PyObject * obj0 = 0 ;
16647 PyObject * obj1 = 0 ;
16648 char * kwnames[] = {
16649 (char *) "self",(char *) "stick", NULL
16650 };
16651
16652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16654 if (!SWIG_IsOK(res1)) {
16655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16656 }
16657 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16658 ecode2 = SWIG_AsVal_int(obj1, &val2);
16659 if (!SWIG_IsOK(ecode2)) {
16660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16661 }
16662 arg2 = static_cast< int >(val2);
16663 {
16664 PyThreadState* __tstate = wxPyBeginAllowThreads();
16665 (arg1)->SetJoystick(arg2);
16666 wxPyEndAllowThreads(__tstate);
16667 if (PyErr_Occurred()) SWIG_fail;
16668 }
16669 resultobj = SWIG_Py_Void();
16670 return resultobj;
16671 fail:
16672 return NULL;
16673 }
16674
16675
16676 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16677 PyObject *resultobj = 0;
16678 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16679 int arg2 ;
16680 void *argp1 = 0 ;
16681 int res1 = 0 ;
16682 int val2 ;
16683 int ecode2 = 0 ;
16684 PyObject * obj0 = 0 ;
16685 PyObject * obj1 = 0 ;
16686 char * kwnames[] = {
16687 (char *) "self",(char *) "state", NULL
16688 };
16689
16690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16692 if (!SWIG_IsOK(res1)) {
16693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16694 }
16695 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16696 ecode2 = SWIG_AsVal_int(obj1, &val2);
16697 if (!SWIG_IsOK(ecode2)) {
16698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16699 }
16700 arg2 = static_cast< int >(val2);
16701 {
16702 PyThreadState* __tstate = wxPyBeginAllowThreads();
16703 (arg1)->SetButtonState(arg2);
16704 wxPyEndAllowThreads(__tstate);
16705 if (PyErr_Occurred()) SWIG_fail;
16706 }
16707 resultobj = SWIG_Py_Void();
16708 return resultobj;
16709 fail:
16710 return NULL;
16711 }
16712
16713
16714 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16715 PyObject *resultobj = 0;
16716 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16717 int arg2 ;
16718 void *argp1 = 0 ;
16719 int res1 = 0 ;
16720 int val2 ;
16721 int ecode2 = 0 ;
16722 PyObject * obj0 = 0 ;
16723 PyObject * obj1 = 0 ;
16724 char * kwnames[] = {
16725 (char *) "self",(char *) "change", NULL
16726 };
16727
16728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16730 if (!SWIG_IsOK(res1)) {
16731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16732 }
16733 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16734 ecode2 = SWIG_AsVal_int(obj1, &val2);
16735 if (!SWIG_IsOK(ecode2)) {
16736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16737 }
16738 arg2 = static_cast< int >(val2);
16739 {
16740 PyThreadState* __tstate = wxPyBeginAllowThreads();
16741 (arg1)->SetButtonChange(arg2);
16742 wxPyEndAllowThreads(__tstate);
16743 if (PyErr_Occurred()) SWIG_fail;
16744 }
16745 resultobj = SWIG_Py_Void();
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj = 0;
16754 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16755 wxPoint *arg2 = 0 ;
16756 void *argp1 = 0 ;
16757 int res1 = 0 ;
16758 wxPoint temp2 ;
16759 PyObject * obj0 = 0 ;
16760 PyObject * obj1 = 0 ;
16761 char * kwnames[] = {
16762 (char *) "self",(char *) "pos", NULL
16763 };
16764
16765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16767 if (!SWIG_IsOK(res1)) {
16768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16769 }
16770 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16771 {
16772 arg2 = &temp2;
16773 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16774 }
16775 {
16776 PyThreadState* __tstate = wxPyBeginAllowThreads();
16777 (arg1)->SetPosition((wxPoint const &)*arg2);
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 resultobj = SWIG_Py_Void();
16782 return resultobj;
16783 fail:
16784 return NULL;
16785 }
16786
16787
16788 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16789 PyObject *resultobj = 0;
16790 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16791 int arg2 ;
16792 void *argp1 = 0 ;
16793 int res1 = 0 ;
16794 int val2 ;
16795 int ecode2 = 0 ;
16796 PyObject * obj0 = 0 ;
16797 PyObject * obj1 = 0 ;
16798 char * kwnames[] = {
16799 (char *) "self",(char *) "zPos", NULL
16800 };
16801
16802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16804 if (!SWIG_IsOK(res1)) {
16805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16806 }
16807 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16808 ecode2 = SWIG_AsVal_int(obj1, &val2);
16809 if (!SWIG_IsOK(ecode2)) {
16810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16811 }
16812 arg2 = static_cast< int >(val2);
16813 {
16814 PyThreadState* __tstate = wxPyBeginAllowThreads();
16815 (arg1)->SetZPosition(arg2);
16816 wxPyEndAllowThreads(__tstate);
16817 if (PyErr_Occurred()) SWIG_fail;
16818 }
16819 resultobj = SWIG_Py_Void();
16820 return resultobj;
16821 fail:
16822 return NULL;
16823 }
16824
16825
16826 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16827 PyObject *resultobj = 0;
16828 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16829 bool result;
16830 void *argp1 = 0 ;
16831 int res1 = 0 ;
16832 PyObject *swig_obj[1] ;
16833
16834 if (!args) SWIG_fail;
16835 swig_obj[0] = args;
16836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16837 if (!SWIG_IsOK(res1)) {
16838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16839 }
16840 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16841 {
16842 PyThreadState* __tstate = wxPyBeginAllowThreads();
16843 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 {
16848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16849 }
16850 return resultobj;
16851 fail:
16852 return NULL;
16853 }
16854
16855
16856 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16857 PyObject *resultobj = 0;
16858 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16859 bool result;
16860 void *argp1 = 0 ;
16861 int res1 = 0 ;
16862 PyObject *swig_obj[1] ;
16863
16864 if (!args) SWIG_fail;
16865 swig_obj[0] = args;
16866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16867 if (!SWIG_IsOK(res1)) {
16868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16869 }
16870 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16874 wxPyEndAllowThreads(__tstate);
16875 if (PyErr_Occurred()) SWIG_fail;
16876 }
16877 {
16878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16879 }
16880 return resultobj;
16881 fail:
16882 return NULL;
16883 }
16884
16885
16886 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16887 PyObject *resultobj = 0;
16888 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16889 bool result;
16890 void *argp1 = 0 ;
16891 int res1 = 0 ;
16892 PyObject *swig_obj[1] ;
16893
16894 if (!args) SWIG_fail;
16895 swig_obj[0] = args;
16896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16897 if (!SWIG_IsOK(res1)) {
16898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16899 }
16900 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16901 {
16902 PyThreadState* __tstate = wxPyBeginAllowThreads();
16903 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16904 wxPyEndAllowThreads(__tstate);
16905 if (PyErr_Occurred()) SWIG_fail;
16906 }
16907 {
16908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16909 }
16910 return resultobj;
16911 fail:
16912 return NULL;
16913 }
16914
16915
16916 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16917 PyObject *resultobj = 0;
16918 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16919 int arg2 = (int) wxJOY_BUTTON_ANY ;
16920 bool result;
16921 void *argp1 = 0 ;
16922 int res1 = 0 ;
16923 int val2 ;
16924 int ecode2 = 0 ;
16925 PyObject * obj0 = 0 ;
16926 PyObject * obj1 = 0 ;
16927 char * kwnames[] = {
16928 (char *) "self",(char *) "but", NULL
16929 };
16930
16931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
16932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16933 if (!SWIG_IsOK(res1)) {
16934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16935 }
16936 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16937 if (obj1) {
16938 ecode2 = SWIG_AsVal_int(obj1, &val2);
16939 if (!SWIG_IsOK(ecode2)) {
16940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
16941 }
16942 arg2 = static_cast< int >(val2);
16943 }
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
16947 wxPyEndAllowThreads(__tstate);
16948 if (PyErr_Occurred()) SWIG_fail;
16949 }
16950 {
16951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16952 }
16953 return resultobj;
16954 fail:
16955 return NULL;
16956 }
16957
16958
16959 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16960 PyObject *resultobj = 0;
16961 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16962 int arg2 = (int) wxJOY_BUTTON_ANY ;
16963 bool result;
16964 void *argp1 = 0 ;
16965 int res1 = 0 ;
16966 int val2 ;
16967 int ecode2 = 0 ;
16968 PyObject * obj0 = 0 ;
16969 PyObject * obj1 = 0 ;
16970 char * kwnames[] = {
16971 (char *) "self",(char *) "but", NULL
16972 };
16973
16974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
16975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16976 if (!SWIG_IsOK(res1)) {
16977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16978 }
16979 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16980 if (obj1) {
16981 ecode2 = SWIG_AsVal_int(obj1, &val2);
16982 if (!SWIG_IsOK(ecode2)) {
16983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
16984 }
16985 arg2 = static_cast< int >(val2);
16986 }
16987 {
16988 PyThreadState* __tstate = wxPyBeginAllowThreads();
16989 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
16990 wxPyEndAllowThreads(__tstate);
16991 if (PyErr_Occurred()) SWIG_fail;
16992 }
16993 {
16994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16995 }
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj = 0;
17004 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17005 int arg2 = (int) wxJOY_BUTTON_ANY ;
17006 bool result;
17007 void *argp1 = 0 ;
17008 int res1 = 0 ;
17009 int val2 ;
17010 int ecode2 = 0 ;
17011 PyObject * obj0 = 0 ;
17012 PyObject * obj1 = 0 ;
17013 char * kwnames[] = {
17014 (char *) "self",(char *) "but", NULL
17015 };
17016
17017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17019 if (!SWIG_IsOK(res1)) {
17020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17021 }
17022 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17023 if (obj1) {
17024 ecode2 = SWIG_AsVal_int(obj1, &val2);
17025 if (!SWIG_IsOK(ecode2)) {
17026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17027 }
17028 arg2 = static_cast< int >(val2);
17029 }
17030 {
17031 PyThreadState* __tstate = wxPyBeginAllowThreads();
17032 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17033 wxPyEndAllowThreads(__tstate);
17034 if (PyErr_Occurred()) SWIG_fail;
17035 }
17036 {
17037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17038 }
17039 return resultobj;
17040 fail:
17041 return NULL;
17042 }
17043
17044
17045 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17046 PyObject *obj;
17047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17048 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17049 return SWIG_Py_Void();
17050 }
17051
17052 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17053 return SWIG_Python_InitShadowInstance(args);
17054 }
17055
17056 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17057 PyObject *resultobj = 0;
17058 wxString const &arg1_defvalue = wxPyEmptyString ;
17059 wxString *arg1 = (wxString *) &arg1_defvalue ;
17060 wxSound *result = 0 ;
17061 bool temp1 = false ;
17062 PyObject * obj0 = 0 ;
17063 char * kwnames[] = {
17064 (char *) "fileName", NULL
17065 };
17066
17067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17068 if (obj0) {
17069 {
17070 arg1 = wxString_in_helper(obj0);
17071 if (arg1 == NULL) SWIG_fail;
17072 temp1 = true;
17073 }
17074 }
17075 {
17076 if (!wxPyCheckForApp()) SWIG_fail;
17077 PyThreadState* __tstate = wxPyBeginAllowThreads();
17078 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17079 wxPyEndAllowThreads(__tstate);
17080 if (PyErr_Occurred()) SWIG_fail;
17081 }
17082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17083 {
17084 if (temp1)
17085 delete arg1;
17086 }
17087 return resultobj;
17088 fail:
17089 {
17090 if (temp1)
17091 delete arg1;
17092 }
17093 return NULL;
17094 }
17095
17096
17097 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17098 PyObject *resultobj = 0;
17099 PyObject *arg1 = (PyObject *) 0 ;
17100 wxSound *result = 0 ;
17101 PyObject * obj0 = 0 ;
17102 char * kwnames[] = {
17103 (char *) "data", NULL
17104 };
17105
17106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17107 arg1 = obj0;
17108 {
17109 if (!wxPyCheckForApp()) SWIG_fail;
17110 PyThreadState* __tstate = wxPyBeginAllowThreads();
17111 result = (wxSound *)new_wxSound(arg1);
17112 wxPyEndAllowThreads(__tstate);
17113 if (PyErr_Occurred()) SWIG_fail;
17114 }
17115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17123 PyObject *resultobj = 0;
17124 wxSound *arg1 = (wxSound *) 0 ;
17125 void *argp1 = 0 ;
17126 int res1 = 0 ;
17127 PyObject *swig_obj[1] ;
17128
17129 if (!args) SWIG_fail;
17130 swig_obj[0] = args;
17131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17132 if (!SWIG_IsOK(res1)) {
17133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17134 }
17135 arg1 = reinterpret_cast< wxSound * >(argp1);
17136 {
17137 PyThreadState* __tstate = wxPyBeginAllowThreads();
17138 delete arg1;
17139
17140 wxPyEndAllowThreads(__tstate);
17141 if (PyErr_Occurred()) SWIG_fail;
17142 }
17143 resultobj = SWIG_Py_Void();
17144 return resultobj;
17145 fail:
17146 return NULL;
17147 }
17148
17149
17150 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17151 PyObject *resultobj = 0;
17152 wxSound *arg1 = (wxSound *) 0 ;
17153 wxString *arg2 = 0 ;
17154 bool result;
17155 void *argp1 = 0 ;
17156 int res1 = 0 ;
17157 bool temp2 = false ;
17158 PyObject * obj0 = 0 ;
17159 PyObject * obj1 = 0 ;
17160 char * kwnames[] = {
17161 (char *) "self",(char *) "fileName", NULL
17162 };
17163
17164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17166 if (!SWIG_IsOK(res1)) {
17167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17168 }
17169 arg1 = reinterpret_cast< wxSound * >(argp1);
17170 {
17171 arg2 = wxString_in_helper(obj1);
17172 if (arg2 == NULL) SWIG_fail;
17173 temp2 = true;
17174 }
17175 {
17176 PyThreadState* __tstate = wxPyBeginAllowThreads();
17177 result = (bool)(arg1)->Create((wxString const &)*arg2);
17178 wxPyEndAllowThreads(__tstate);
17179 if (PyErr_Occurred()) SWIG_fail;
17180 }
17181 {
17182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17183 }
17184 {
17185 if (temp2)
17186 delete arg2;
17187 }
17188 return resultobj;
17189 fail:
17190 {
17191 if (temp2)
17192 delete arg2;
17193 }
17194 return NULL;
17195 }
17196
17197
17198 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17199 PyObject *resultobj = 0;
17200 wxSound *arg1 = (wxSound *) 0 ;
17201 PyObject *arg2 = (PyObject *) 0 ;
17202 bool result;
17203 void *argp1 = 0 ;
17204 int res1 = 0 ;
17205 PyObject * obj0 = 0 ;
17206 PyObject * obj1 = 0 ;
17207 char * kwnames[] = {
17208 (char *) "self",(char *) "data", NULL
17209 };
17210
17211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17213 if (!SWIG_IsOK(res1)) {
17214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17215 }
17216 arg1 = reinterpret_cast< wxSound * >(argp1);
17217 arg2 = obj1;
17218 {
17219 PyThreadState* __tstate = wxPyBeginAllowThreads();
17220 result = (bool)wxSound_CreateFromData(arg1,arg2);
17221 wxPyEndAllowThreads(__tstate);
17222 if (PyErr_Occurred()) SWIG_fail;
17223 }
17224 {
17225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17226 }
17227 return resultobj;
17228 fail:
17229 return NULL;
17230 }
17231
17232
17233 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17234 PyObject *resultobj = 0;
17235 wxSound *arg1 = (wxSound *) 0 ;
17236 bool result;
17237 void *argp1 = 0 ;
17238 int res1 = 0 ;
17239 PyObject *swig_obj[1] ;
17240
17241 if (!args) SWIG_fail;
17242 swig_obj[0] = args;
17243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17244 if (!SWIG_IsOK(res1)) {
17245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17246 }
17247 arg1 = reinterpret_cast< wxSound * >(argp1);
17248 {
17249 PyThreadState* __tstate = wxPyBeginAllowThreads();
17250 result = (bool)(arg1)->IsOk();
17251 wxPyEndAllowThreads(__tstate);
17252 if (PyErr_Occurred()) SWIG_fail;
17253 }
17254 {
17255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17256 }
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17264 PyObject *resultobj = 0;
17265 wxSound *arg1 = (wxSound *) 0 ;
17266 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17267 bool result;
17268 void *argp1 = 0 ;
17269 int res1 = 0 ;
17270 unsigned int val2 ;
17271 int ecode2 = 0 ;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 char * kwnames[] = {
17275 (char *) "self",(char *) "flags", NULL
17276 };
17277
17278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17280 if (!SWIG_IsOK(res1)) {
17281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17282 }
17283 arg1 = reinterpret_cast< wxSound * >(argp1);
17284 if (obj1) {
17285 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17286 if (!SWIG_IsOK(ecode2)) {
17287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17288 }
17289 arg2 = static_cast< unsigned int >(val2);
17290 }
17291 {
17292 if (!wxPyCheckForApp()) SWIG_fail;
17293 PyThreadState* __tstate = wxPyBeginAllowThreads();
17294 result = (bool)((wxSound const *)arg1)->Play(arg2);
17295 wxPyEndAllowThreads(__tstate);
17296 if (PyErr_Occurred()) SWIG_fail;
17297 }
17298 {
17299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17300 }
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17308 PyObject *resultobj = 0;
17309 wxString *arg1 = 0 ;
17310 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17311 bool result;
17312 bool temp1 = false ;
17313 unsigned int val2 ;
17314 int ecode2 = 0 ;
17315 PyObject * obj0 = 0 ;
17316 PyObject * obj1 = 0 ;
17317 char * kwnames[] = {
17318 (char *) "filename",(char *) "flags", NULL
17319 };
17320
17321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17322 {
17323 arg1 = wxString_in_helper(obj0);
17324 if (arg1 == NULL) SWIG_fail;
17325 temp1 = true;
17326 }
17327 if (obj1) {
17328 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17329 if (!SWIG_IsOK(ecode2)) {
17330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17331 }
17332 arg2 = static_cast< unsigned int >(val2);
17333 }
17334 {
17335 if (!wxPyCheckForApp()) SWIG_fail;
17336 PyThreadState* __tstate = wxPyBeginAllowThreads();
17337 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17338 wxPyEndAllowThreads(__tstate);
17339 if (PyErr_Occurred()) SWIG_fail;
17340 }
17341 {
17342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17343 }
17344 {
17345 if (temp1)
17346 delete arg1;
17347 }
17348 return resultobj;
17349 fail:
17350 {
17351 if (temp1)
17352 delete arg1;
17353 }
17354 return NULL;
17355 }
17356
17357
17358 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17359 PyObject *resultobj = 0;
17360
17361 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17362 {
17363 if (!wxPyCheckForApp()) SWIG_fail;
17364 PyThreadState* __tstate = wxPyBeginAllowThreads();
17365 wxSound::Stop();
17366 wxPyEndAllowThreads(__tstate);
17367 if (PyErr_Occurred()) SWIG_fail;
17368 }
17369 resultobj = SWIG_Py_Void();
17370 return resultobj;
17371 fail:
17372 return NULL;
17373 }
17374
17375
17376 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17377 PyObject *obj;
17378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17379 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17380 return SWIG_Py_Void();
17381 }
17382
17383 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17384 return SWIG_Python_InitShadowInstance(args);
17385 }
17386
17387 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17388 PyObject *resultobj = 0;
17389 wxString *arg1 = 0 ;
17390 wxString *arg2 = 0 ;
17391 wxString *arg3 = 0 ;
17392 wxString *arg4 = 0 ;
17393 wxFileTypeInfo *result = 0 ;
17394 bool temp1 = false ;
17395 bool temp2 = false ;
17396 bool temp3 = false ;
17397 bool temp4 = false ;
17398 PyObject * obj0 = 0 ;
17399 PyObject * obj1 = 0 ;
17400 PyObject * obj2 = 0 ;
17401 PyObject * obj3 = 0 ;
17402 char * kwnames[] = {
17403 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17404 };
17405
17406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17407 {
17408 arg1 = wxString_in_helper(obj0);
17409 if (arg1 == NULL) SWIG_fail;
17410 temp1 = true;
17411 }
17412 {
17413 arg2 = wxString_in_helper(obj1);
17414 if (arg2 == NULL) SWIG_fail;
17415 temp2 = true;
17416 }
17417 {
17418 arg3 = wxString_in_helper(obj2);
17419 if (arg3 == NULL) SWIG_fail;
17420 temp3 = true;
17421 }
17422 {
17423 arg4 = wxString_in_helper(obj3);
17424 if (arg4 == NULL) SWIG_fail;
17425 temp4 = true;
17426 }
17427 {
17428 PyThreadState* __tstate = wxPyBeginAllowThreads();
17429 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17430 wxPyEndAllowThreads(__tstate);
17431 if (PyErr_Occurred()) SWIG_fail;
17432 }
17433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17434 {
17435 if (temp1)
17436 delete arg1;
17437 }
17438 {
17439 if (temp2)
17440 delete arg2;
17441 }
17442 {
17443 if (temp3)
17444 delete arg3;
17445 }
17446 {
17447 if (temp4)
17448 delete arg4;
17449 }
17450 return resultobj;
17451 fail:
17452 {
17453 if (temp1)
17454 delete arg1;
17455 }
17456 {
17457 if (temp2)
17458 delete arg2;
17459 }
17460 {
17461 if (temp3)
17462 delete arg3;
17463 }
17464 {
17465 if (temp4)
17466 delete arg4;
17467 }
17468 return NULL;
17469 }
17470
17471
17472 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17473 PyObject *resultobj = 0;
17474 wxArrayString *arg1 = 0 ;
17475 wxFileTypeInfo *result = 0 ;
17476 bool temp1 = false ;
17477 PyObject * obj0 = 0 ;
17478 char * kwnames[] = {
17479 (char *) "sArray", NULL
17480 };
17481
17482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17483 {
17484 if (! PySequence_Check(obj0)) {
17485 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17486 SWIG_fail;
17487 }
17488 arg1 = new wxArrayString;
17489 temp1 = true;
17490 int i, len=PySequence_Length(obj0);
17491 for (i=0; i<len; i++) {
17492 PyObject* item = PySequence_GetItem(obj0, i);
17493 wxString* s = wxString_in_helper(item);
17494 if (PyErr_Occurred()) SWIG_fail;
17495 arg1->Add(*s);
17496 delete s;
17497 Py_DECREF(item);
17498 }
17499 }
17500 {
17501 PyThreadState* __tstate = wxPyBeginAllowThreads();
17502 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17503 wxPyEndAllowThreads(__tstate);
17504 if (PyErr_Occurred()) SWIG_fail;
17505 }
17506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17507 {
17508 if (temp1) delete arg1;
17509 }
17510 return resultobj;
17511 fail:
17512 {
17513 if (temp1) delete arg1;
17514 }
17515 return NULL;
17516 }
17517
17518
17519 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17520 PyObject *resultobj = 0;
17521 wxFileTypeInfo *result = 0 ;
17522
17523 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17524 {
17525 PyThreadState* __tstate = wxPyBeginAllowThreads();
17526 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17527 wxPyEndAllowThreads(__tstate);
17528 if (PyErr_Occurred()) SWIG_fail;
17529 }
17530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17538 PyObject *resultobj = 0;
17539 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17540 bool result;
17541 void *argp1 = 0 ;
17542 int res1 = 0 ;
17543 PyObject *swig_obj[1] ;
17544
17545 if (!args) SWIG_fail;
17546 swig_obj[0] = args;
17547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17548 if (!SWIG_IsOK(res1)) {
17549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17550 }
17551 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 {
17559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17560 }
17561 return resultobj;
17562 fail:
17563 return NULL;
17564 }
17565
17566
17567 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17568 PyObject *resultobj = 0;
17569 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17570 wxString *arg2 = 0 ;
17571 int arg3 = (int) 0 ;
17572 void *argp1 = 0 ;
17573 int res1 = 0 ;
17574 bool temp2 = false ;
17575 int val3 ;
17576 int ecode3 = 0 ;
17577 PyObject * obj0 = 0 ;
17578 PyObject * obj1 = 0 ;
17579 PyObject * obj2 = 0 ;
17580 char * kwnames[] = {
17581 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17582 };
17583
17584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17586 if (!SWIG_IsOK(res1)) {
17587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17588 }
17589 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17590 {
17591 arg2 = wxString_in_helper(obj1);
17592 if (arg2 == NULL) SWIG_fail;
17593 temp2 = true;
17594 }
17595 if (obj2) {
17596 ecode3 = SWIG_AsVal_int(obj2, &val3);
17597 if (!SWIG_IsOK(ecode3)) {
17598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17599 }
17600 arg3 = static_cast< int >(val3);
17601 }
17602 {
17603 PyThreadState* __tstate = wxPyBeginAllowThreads();
17604 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17605 wxPyEndAllowThreads(__tstate);
17606 if (PyErr_Occurred()) SWIG_fail;
17607 }
17608 resultobj = SWIG_Py_Void();
17609 {
17610 if (temp2)
17611 delete arg2;
17612 }
17613 return resultobj;
17614 fail:
17615 {
17616 if (temp2)
17617 delete arg2;
17618 }
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17624 PyObject *resultobj = 0;
17625 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17626 wxString *arg2 = 0 ;
17627 void *argp1 = 0 ;
17628 int res1 = 0 ;
17629 bool temp2 = false ;
17630 PyObject * obj0 = 0 ;
17631 PyObject * obj1 = 0 ;
17632 char * kwnames[] = {
17633 (char *) "self",(char *) "shortDesc", NULL
17634 };
17635
17636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17638 if (!SWIG_IsOK(res1)) {
17639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17640 }
17641 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17642 {
17643 arg2 = wxString_in_helper(obj1);
17644 if (arg2 == NULL) SWIG_fail;
17645 temp2 = true;
17646 }
17647 {
17648 PyThreadState* __tstate = wxPyBeginAllowThreads();
17649 (arg1)->SetShortDesc((wxString const &)*arg2);
17650 wxPyEndAllowThreads(__tstate);
17651 if (PyErr_Occurred()) SWIG_fail;
17652 }
17653 resultobj = SWIG_Py_Void();
17654 {
17655 if (temp2)
17656 delete arg2;
17657 }
17658 return resultobj;
17659 fail:
17660 {
17661 if (temp2)
17662 delete arg2;
17663 }
17664 return NULL;
17665 }
17666
17667
17668 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17669 PyObject *resultobj = 0;
17670 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17671 wxString *result = 0 ;
17672 void *argp1 = 0 ;
17673 int res1 = 0 ;
17674 PyObject *swig_obj[1] ;
17675
17676 if (!args) SWIG_fail;
17677 swig_obj[0] = args;
17678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17679 if (!SWIG_IsOK(res1)) {
17680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17681 }
17682 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 {
17686 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17687 result = (wxString *) &_result_ref;
17688 }
17689 wxPyEndAllowThreads(__tstate);
17690 if (PyErr_Occurred()) SWIG_fail;
17691 }
17692 {
17693 #if wxUSE_UNICODE
17694 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17695 #else
17696 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17697 #endif
17698 }
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17706 PyObject *resultobj = 0;
17707 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17708 wxString *result = 0 ;
17709 void *argp1 = 0 ;
17710 int res1 = 0 ;
17711 PyObject *swig_obj[1] ;
17712
17713 if (!args) SWIG_fail;
17714 swig_obj[0] = args;
17715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17716 if (!SWIG_IsOK(res1)) {
17717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17718 }
17719 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17720 {
17721 PyThreadState* __tstate = wxPyBeginAllowThreads();
17722 {
17723 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17724 result = (wxString *) &_result_ref;
17725 }
17726 wxPyEndAllowThreads(__tstate);
17727 if (PyErr_Occurred()) SWIG_fail;
17728 }
17729 {
17730 #if wxUSE_UNICODE
17731 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17732 #else
17733 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17734 #endif
17735 }
17736 return resultobj;
17737 fail:
17738 return NULL;
17739 }
17740
17741
17742 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17743 PyObject *resultobj = 0;
17744 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17745 wxString *result = 0 ;
17746 void *argp1 = 0 ;
17747 int res1 = 0 ;
17748 PyObject *swig_obj[1] ;
17749
17750 if (!args) SWIG_fail;
17751 swig_obj[0] = args;
17752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17753 if (!SWIG_IsOK(res1)) {
17754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17755 }
17756 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17757 {
17758 PyThreadState* __tstate = wxPyBeginAllowThreads();
17759 {
17760 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17761 result = (wxString *) &_result_ref;
17762 }
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 {
17767 #if wxUSE_UNICODE
17768 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17769 #else
17770 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17771 #endif
17772 }
17773 return resultobj;
17774 fail:
17775 return NULL;
17776 }
17777
17778
17779 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17780 PyObject *resultobj = 0;
17781 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17782 wxString *result = 0 ;
17783 void *argp1 = 0 ;
17784 int res1 = 0 ;
17785 PyObject *swig_obj[1] ;
17786
17787 if (!args) SWIG_fail;
17788 swig_obj[0] = args;
17789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17790 if (!SWIG_IsOK(res1)) {
17791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17792 }
17793 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17794 {
17795 PyThreadState* __tstate = wxPyBeginAllowThreads();
17796 {
17797 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17798 result = (wxString *) &_result_ref;
17799 }
17800 wxPyEndAllowThreads(__tstate);
17801 if (PyErr_Occurred()) SWIG_fail;
17802 }
17803 {
17804 #if wxUSE_UNICODE
17805 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17806 #else
17807 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17808 #endif
17809 }
17810 return resultobj;
17811 fail:
17812 return NULL;
17813 }
17814
17815
17816 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17817 PyObject *resultobj = 0;
17818 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17819 wxString *result = 0 ;
17820 void *argp1 = 0 ;
17821 int res1 = 0 ;
17822 PyObject *swig_obj[1] ;
17823
17824 if (!args) SWIG_fail;
17825 swig_obj[0] = args;
17826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17827 if (!SWIG_IsOK(res1)) {
17828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17829 }
17830 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17831 {
17832 PyThreadState* __tstate = wxPyBeginAllowThreads();
17833 {
17834 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17835 result = (wxString *) &_result_ref;
17836 }
17837 wxPyEndAllowThreads(__tstate);
17838 if (PyErr_Occurred()) SWIG_fail;
17839 }
17840 {
17841 #if wxUSE_UNICODE
17842 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17843 #else
17844 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17845 #endif
17846 }
17847 return resultobj;
17848 fail:
17849 return NULL;
17850 }
17851
17852
17853 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17854 PyObject *resultobj = 0;
17855 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17856 wxArrayString *result = 0 ;
17857 void *argp1 = 0 ;
17858 int res1 = 0 ;
17859 PyObject *swig_obj[1] ;
17860
17861 if (!args) SWIG_fail;
17862 swig_obj[0] = args;
17863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17864 if (!SWIG_IsOK(res1)) {
17865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17866 }
17867 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17868 {
17869 PyThreadState* __tstate = wxPyBeginAllowThreads();
17870 {
17871 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17872 result = (wxArrayString *) &_result_ref;
17873 }
17874 wxPyEndAllowThreads(__tstate);
17875 if (PyErr_Occurred()) SWIG_fail;
17876 }
17877 {
17878 resultobj = wxArrayString2PyList_helper(*result);
17879 }
17880 return resultobj;
17881 fail:
17882 return NULL;
17883 }
17884
17885
17886 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17887 PyObject *resultobj = 0;
17888 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17889 size_t result;
17890 void *argp1 = 0 ;
17891 int res1 = 0 ;
17892 PyObject *swig_obj[1] ;
17893
17894 if (!args) SWIG_fail;
17895 swig_obj[0] = args;
17896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17897 if (!SWIG_IsOK(res1)) {
17898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17899 }
17900 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17901 {
17902 PyThreadState* __tstate = wxPyBeginAllowThreads();
17903 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17904 wxPyEndAllowThreads(__tstate);
17905 if (PyErr_Occurred()) SWIG_fail;
17906 }
17907 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
17908 return resultobj;
17909 fail:
17910 return NULL;
17911 }
17912
17913
17914 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17915 PyObject *resultobj = 0;
17916 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17917 wxString *result = 0 ;
17918 void *argp1 = 0 ;
17919 int res1 = 0 ;
17920 PyObject *swig_obj[1] ;
17921
17922 if (!args) SWIG_fail;
17923 swig_obj[0] = args;
17924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17925 if (!SWIG_IsOK(res1)) {
17926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17927 }
17928 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17929 {
17930 PyThreadState* __tstate = wxPyBeginAllowThreads();
17931 {
17932 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
17933 result = (wxString *) &_result_ref;
17934 }
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 {
17939 #if wxUSE_UNICODE
17940 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17941 #else
17942 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17943 #endif
17944 }
17945 return resultobj;
17946 fail:
17947 return NULL;
17948 }
17949
17950
17951 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17952 PyObject *resultobj = 0;
17953 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17954 int result;
17955 void *argp1 = 0 ;
17956 int res1 = 0 ;
17957 PyObject *swig_obj[1] ;
17958
17959 if (!args) SWIG_fail;
17960 swig_obj[0] = args;
17961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17962 if (!SWIG_IsOK(res1)) {
17963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17964 }
17965 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17966 {
17967 PyThreadState* __tstate = wxPyBeginAllowThreads();
17968 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
17969 wxPyEndAllowThreads(__tstate);
17970 if (PyErr_Occurred()) SWIG_fail;
17971 }
17972 resultobj = SWIG_From_int(static_cast< int >(result));
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17980 PyObject *obj;
17981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17982 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
17983 return SWIG_Py_Void();
17984 }
17985
17986 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17987 return SWIG_Python_InitShadowInstance(args);
17988 }
17989
17990 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17991 PyObject *resultobj = 0;
17992 wxFileTypeInfo *arg1 = 0 ;
17993 wxFileType *result = 0 ;
17994 void *argp1 = 0 ;
17995 int res1 = 0 ;
17996 PyObject * obj0 = 0 ;
17997 char * kwnames[] = {
17998 (char *) "ftInfo", NULL
17999 };
18000
18001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18002 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18003 if (!SWIG_IsOK(res1)) {
18004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18005 }
18006 if (!argp1) {
18007 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18008 }
18009 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18010 {
18011 PyThreadState* __tstate = wxPyBeginAllowThreads();
18012 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18013 wxPyEndAllowThreads(__tstate);
18014 if (PyErr_Occurred()) SWIG_fail;
18015 }
18016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18024 PyObject *resultobj = 0;
18025 wxFileType *arg1 = (wxFileType *) 0 ;
18026 void *argp1 = 0 ;
18027 int res1 = 0 ;
18028 PyObject *swig_obj[1] ;
18029
18030 if (!args) SWIG_fail;
18031 swig_obj[0] = args;
18032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18033 if (!SWIG_IsOK(res1)) {
18034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18035 }
18036 arg1 = reinterpret_cast< wxFileType * >(argp1);
18037 {
18038 PyThreadState* __tstate = wxPyBeginAllowThreads();
18039 delete arg1;
18040
18041 wxPyEndAllowThreads(__tstate);
18042 if (PyErr_Occurred()) SWIG_fail;
18043 }
18044 resultobj = SWIG_Py_Void();
18045 return resultobj;
18046 fail:
18047 return NULL;
18048 }
18049
18050
18051 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18052 PyObject *resultobj = 0;
18053 wxFileType *arg1 = (wxFileType *) 0 ;
18054 PyObject *result = 0 ;
18055 void *argp1 = 0 ;
18056 int res1 = 0 ;
18057 PyObject *swig_obj[1] ;
18058
18059 if (!args) SWIG_fail;
18060 swig_obj[0] = args;
18061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18062 if (!SWIG_IsOK(res1)) {
18063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18064 }
18065 arg1 = reinterpret_cast< wxFileType * >(argp1);
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 result = (PyObject *)wxFileType_GetMimeType(arg1);
18069 wxPyEndAllowThreads(__tstate);
18070 if (PyErr_Occurred()) SWIG_fail;
18071 }
18072 resultobj = result;
18073 return resultobj;
18074 fail:
18075 return NULL;
18076 }
18077
18078
18079 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18080 PyObject *resultobj = 0;
18081 wxFileType *arg1 = (wxFileType *) 0 ;
18082 PyObject *result = 0 ;
18083 void *argp1 = 0 ;
18084 int res1 = 0 ;
18085 PyObject *swig_obj[1] ;
18086
18087 if (!args) SWIG_fail;
18088 swig_obj[0] = args;
18089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18090 if (!SWIG_IsOK(res1)) {
18091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18092 }
18093 arg1 = reinterpret_cast< wxFileType * >(argp1);
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 resultobj = result;
18101 return resultobj;
18102 fail:
18103 return NULL;
18104 }
18105
18106
18107 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18108 PyObject *resultobj = 0;
18109 wxFileType *arg1 = (wxFileType *) 0 ;
18110 PyObject *result = 0 ;
18111 void *argp1 = 0 ;
18112 int res1 = 0 ;
18113 PyObject *swig_obj[1] ;
18114
18115 if (!args) SWIG_fail;
18116 swig_obj[0] = args;
18117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18118 if (!SWIG_IsOK(res1)) {
18119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18120 }
18121 arg1 = reinterpret_cast< wxFileType * >(argp1);
18122 {
18123 PyThreadState* __tstate = wxPyBeginAllowThreads();
18124 result = (PyObject *)wxFileType_GetExtensions(arg1);
18125 wxPyEndAllowThreads(__tstate);
18126 if (PyErr_Occurred()) SWIG_fail;
18127 }
18128 resultobj = result;
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18136 PyObject *resultobj = 0;
18137 wxFileType *arg1 = (wxFileType *) 0 ;
18138 wxIcon *result = 0 ;
18139 void *argp1 = 0 ;
18140 int res1 = 0 ;
18141 PyObject *swig_obj[1] ;
18142
18143 if (!args) SWIG_fail;
18144 swig_obj[0] = args;
18145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18146 if (!SWIG_IsOK(res1)) {
18147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18148 }
18149 arg1 = reinterpret_cast< wxFileType * >(argp1);
18150 {
18151 PyThreadState* __tstate = wxPyBeginAllowThreads();
18152 result = (wxIcon *)wxFileType_GetIcon(arg1);
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18164 PyObject *resultobj = 0;
18165 wxFileType *arg1 = (wxFileType *) 0 ;
18166 PyObject *result = 0 ;
18167 void *argp1 = 0 ;
18168 int res1 = 0 ;
18169 PyObject *swig_obj[1] ;
18170
18171 if (!args) SWIG_fail;
18172 swig_obj[0] = args;
18173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18174 if (!SWIG_IsOK(res1)) {
18175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18176 }
18177 arg1 = reinterpret_cast< wxFileType * >(argp1);
18178 {
18179 PyThreadState* __tstate = wxPyBeginAllowThreads();
18180 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 resultobj = result;
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18192 PyObject *resultobj = 0;
18193 wxFileType *arg1 = (wxFileType *) 0 ;
18194 PyObject *result = 0 ;
18195 void *argp1 = 0 ;
18196 int res1 = 0 ;
18197 PyObject *swig_obj[1] ;
18198
18199 if (!args) SWIG_fail;
18200 swig_obj[0] = args;
18201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18202 if (!SWIG_IsOK(res1)) {
18203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18204 }
18205 arg1 = reinterpret_cast< wxFileType * >(argp1);
18206 {
18207 PyThreadState* __tstate = wxPyBeginAllowThreads();
18208 result = (PyObject *)wxFileType_GetDescription(arg1);
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 resultobj = result;
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18220 PyObject *resultobj = 0;
18221 wxFileType *arg1 = (wxFileType *) 0 ;
18222 wxString *arg2 = 0 ;
18223 wxString const &arg3_defvalue = wxPyEmptyString ;
18224 wxString *arg3 = (wxString *) &arg3_defvalue ;
18225 PyObject *result = 0 ;
18226 void *argp1 = 0 ;
18227 int res1 = 0 ;
18228 bool temp2 = false ;
18229 bool temp3 = false ;
18230 PyObject * obj0 = 0 ;
18231 PyObject * obj1 = 0 ;
18232 PyObject * obj2 = 0 ;
18233 char * kwnames[] = {
18234 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18235 };
18236
18237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18239 if (!SWIG_IsOK(res1)) {
18240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18241 }
18242 arg1 = reinterpret_cast< wxFileType * >(argp1);
18243 {
18244 arg2 = wxString_in_helper(obj1);
18245 if (arg2 == NULL) SWIG_fail;
18246 temp2 = true;
18247 }
18248 if (obj2) {
18249 {
18250 arg3 = wxString_in_helper(obj2);
18251 if (arg3 == NULL) SWIG_fail;
18252 temp3 = true;
18253 }
18254 }
18255 {
18256 PyThreadState* __tstate = wxPyBeginAllowThreads();
18257 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18258 wxPyEndAllowThreads(__tstate);
18259 if (PyErr_Occurred()) SWIG_fail;
18260 }
18261 resultobj = result;
18262 {
18263 if (temp2)
18264 delete arg2;
18265 }
18266 {
18267 if (temp3)
18268 delete arg3;
18269 }
18270 return resultobj;
18271 fail:
18272 {
18273 if (temp2)
18274 delete arg2;
18275 }
18276 {
18277 if (temp3)
18278 delete arg3;
18279 }
18280 return NULL;
18281 }
18282
18283
18284 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18285 PyObject *resultobj = 0;
18286 wxFileType *arg1 = (wxFileType *) 0 ;
18287 wxString *arg2 = 0 ;
18288 wxString const &arg3_defvalue = wxPyEmptyString ;
18289 wxString *arg3 = (wxString *) &arg3_defvalue ;
18290 PyObject *result = 0 ;
18291 void *argp1 = 0 ;
18292 int res1 = 0 ;
18293 bool temp2 = false ;
18294 bool temp3 = false ;
18295 PyObject * obj0 = 0 ;
18296 PyObject * obj1 = 0 ;
18297 PyObject * obj2 = 0 ;
18298 char * kwnames[] = {
18299 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18300 };
18301
18302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18304 if (!SWIG_IsOK(res1)) {
18305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18306 }
18307 arg1 = reinterpret_cast< wxFileType * >(argp1);
18308 {
18309 arg2 = wxString_in_helper(obj1);
18310 if (arg2 == NULL) SWIG_fail;
18311 temp2 = true;
18312 }
18313 if (obj2) {
18314 {
18315 arg3 = wxString_in_helper(obj2);
18316 if (arg3 == NULL) SWIG_fail;
18317 temp3 = true;
18318 }
18319 }
18320 {
18321 PyThreadState* __tstate = wxPyBeginAllowThreads();
18322 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18323 wxPyEndAllowThreads(__tstate);
18324 if (PyErr_Occurred()) SWIG_fail;
18325 }
18326 resultobj = result;
18327 {
18328 if (temp2)
18329 delete arg2;
18330 }
18331 {
18332 if (temp3)
18333 delete arg3;
18334 }
18335 return resultobj;
18336 fail:
18337 {
18338 if (temp2)
18339 delete arg2;
18340 }
18341 {
18342 if (temp3)
18343 delete arg3;
18344 }
18345 return NULL;
18346 }
18347
18348
18349 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18350 PyObject *resultobj = 0;
18351 wxFileType *arg1 = (wxFileType *) 0 ;
18352 wxString *arg2 = 0 ;
18353 wxString const &arg3_defvalue = wxPyEmptyString ;
18354 wxString *arg3 = (wxString *) &arg3_defvalue ;
18355 PyObject *result = 0 ;
18356 void *argp1 = 0 ;
18357 int res1 = 0 ;
18358 bool temp2 = false ;
18359 bool temp3 = false ;
18360 PyObject * obj0 = 0 ;
18361 PyObject * obj1 = 0 ;
18362 PyObject * obj2 = 0 ;
18363 char * kwnames[] = {
18364 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18365 };
18366
18367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18369 if (!SWIG_IsOK(res1)) {
18370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18371 }
18372 arg1 = reinterpret_cast< wxFileType * >(argp1);
18373 {
18374 arg2 = wxString_in_helper(obj1);
18375 if (arg2 == NULL) SWIG_fail;
18376 temp2 = true;
18377 }
18378 if (obj2) {
18379 {
18380 arg3 = wxString_in_helper(obj2);
18381 if (arg3 == NULL) SWIG_fail;
18382 temp3 = true;
18383 }
18384 }
18385 {
18386 PyThreadState* __tstate = wxPyBeginAllowThreads();
18387 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18388 wxPyEndAllowThreads(__tstate);
18389 if (PyErr_Occurred()) SWIG_fail;
18390 }
18391 resultobj = result;
18392 {
18393 if (temp2)
18394 delete arg2;
18395 }
18396 {
18397 if (temp3)
18398 delete arg3;
18399 }
18400 return resultobj;
18401 fail:
18402 {
18403 if (temp2)
18404 delete arg2;
18405 }
18406 {
18407 if (temp3)
18408 delete arg3;
18409 }
18410 return NULL;
18411 }
18412
18413
18414 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18415 PyObject *resultobj = 0;
18416 wxFileType *arg1 = (wxFileType *) 0 ;
18417 wxString *arg2 = 0 ;
18418 wxString *arg3 = 0 ;
18419 bool arg4 = (bool) true ;
18420 bool result;
18421 void *argp1 = 0 ;
18422 int res1 = 0 ;
18423 bool temp2 = false ;
18424 bool temp3 = false ;
18425 bool val4 ;
18426 int ecode4 = 0 ;
18427 PyObject * obj0 = 0 ;
18428 PyObject * obj1 = 0 ;
18429 PyObject * obj2 = 0 ;
18430 PyObject * obj3 = 0 ;
18431 char * kwnames[] = {
18432 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18433 };
18434
18435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18437 if (!SWIG_IsOK(res1)) {
18438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18439 }
18440 arg1 = reinterpret_cast< wxFileType * >(argp1);
18441 {
18442 arg2 = wxString_in_helper(obj1);
18443 if (arg2 == NULL) SWIG_fail;
18444 temp2 = true;
18445 }
18446 {
18447 arg3 = wxString_in_helper(obj2);
18448 if (arg3 == NULL) SWIG_fail;
18449 temp3 = true;
18450 }
18451 if (obj3) {
18452 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18453 if (!SWIG_IsOK(ecode4)) {
18454 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18455 }
18456 arg4 = static_cast< bool >(val4);
18457 }
18458 {
18459 PyThreadState* __tstate = wxPyBeginAllowThreads();
18460 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18461 wxPyEndAllowThreads(__tstate);
18462 if (PyErr_Occurred()) SWIG_fail;
18463 }
18464 {
18465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18466 }
18467 {
18468 if (temp2)
18469 delete arg2;
18470 }
18471 {
18472 if (temp3)
18473 delete arg3;
18474 }
18475 return resultobj;
18476 fail:
18477 {
18478 if (temp2)
18479 delete arg2;
18480 }
18481 {
18482 if (temp3)
18483 delete arg3;
18484 }
18485 return NULL;
18486 }
18487
18488
18489 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18490 PyObject *resultobj = 0;
18491 wxFileType *arg1 = (wxFileType *) 0 ;
18492 wxString const &arg2_defvalue = wxPyEmptyString ;
18493 wxString *arg2 = (wxString *) &arg2_defvalue ;
18494 int arg3 = (int) 0 ;
18495 bool result;
18496 void *argp1 = 0 ;
18497 int res1 = 0 ;
18498 bool temp2 = false ;
18499 int val3 ;
18500 int ecode3 = 0 ;
18501 PyObject * obj0 = 0 ;
18502 PyObject * obj1 = 0 ;
18503 PyObject * obj2 = 0 ;
18504 char * kwnames[] = {
18505 (char *) "self",(char *) "cmd",(char *) "index", NULL
18506 };
18507
18508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18510 if (!SWIG_IsOK(res1)) {
18511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18512 }
18513 arg1 = reinterpret_cast< wxFileType * >(argp1);
18514 if (obj1) {
18515 {
18516 arg2 = wxString_in_helper(obj1);
18517 if (arg2 == NULL) SWIG_fail;
18518 temp2 = true;
18519 }
18520 }
18521 if (obj2) {
18522 ecode3 = SWIG_AsVal_int(obj2, &val3);
18523 if (!SWIG_IsOK(ecode3)) {
18524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18525 }
18526 arg3 = static_cast< int >(val3);
18527 }
18528 {
18529 PyThreadState* __tstate = wxPyBeginAllowThreads();
18530 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18531 wxPyEndAllowThreads(__tstate);
18532 if (PyErr_Occurred()) SWIG_fail;
18533 }
18534 {
18535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18536 }
18537 {
18538 if (temp2)
18539 delete arg2;
18540 }
18541 return resultobj;
18542 fail:
18543 {
18544 if (temp2)
18545 delete arg2;
18546 }
18547 return NULL;
18548 }
18549
18550
18551 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18552 PyObject *resultobj = 0;
18553 wxFileType *arg1 = (wxFileType *) 0 ;
18554 bool result;
18555 void *argp1 = 0 ;
18556 int res1 = 0 ;
18557 PyObject *swig_obj[1] ;
18558
18559 if (!args) SWIG_fail;
18560 swig_obj[0] = args;
18561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18562 if (!SWIG_IsOK(res1)) {
18563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18564 }
18565 arg1 = reinterpret_cast< wxFileType * >(argp1);
18566 {
18567 PyThreadState* __tstate = wxPyBeginAllowThreads();
18568 result = (bool)(arg1)->Unassociate();
18569 wxPyEndAllowThreads(__tstate);
18570 if (PyErr_Occurred()) SWIG_fail;
18571 }
18572 {
18573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18574 }
18575 return resultobj;
18576 fail:
18577 return NULL;
18578 }
18579
18580
18581 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18582 PyObject *resultobj = 0;
18583 wxString *arg1 = 0 ;
18584 wxString *arg2 = 0 ;
18585 wxString const &arg3_defvalue = wxPyEmptyString ;
18586 wxString *arg3 = (wxString *) &arg3_defvalue ;
18587 wxString result;
18588 bool temp1 = false ;
18589 bool temp2 = false ;
18590 bool temp3 = false ;
18591 PyObject * obj0 = 0 ;
18592 PyObject * obj1 = 0 ;
18593 PyObject * obj2 = 0 ;
18594 char * kwnames[] = {
18595 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18596 };
18597
18598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18599 {
18600 arg1 = wxString_in_helper(obj0);
18601 if (arg1 == NULL) SWIG_fail;
18602 temp1 = true;
18603 }
18604 {
18605 arg2 = wxString_in_helper(obj1);
18606 if (arg2 == NULL) SWIG_fail;
18607 temp2 = true;
18608 }
18609 if (obj2) {
18610 {
18611 arg3 = wxString_in_helper(obj2);
18612 if (arg3 == NULL) SWIG_fail;
18613 temp3 = true;
18614 }
18615 }
18616 {
18617 PyThreadState* __tstate = wxPyBeginAllowThreads();
18618 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18619 wxPyEndAllowThreads(__tstate);
18620 if (PyErr_Occurred()) SWIG_fail;
18621 }
18622 {
18623 #if wxUSE_UNICODE
18624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18625 #else
18626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18627 #endif
18628 }
18629 {
18630 if (temp1)
18631 delete arg1;
18632 }
18633 {
18634 if (temp2)
18635 delete arg2;
18636 }
18637 {
18638 if (temp3)
18639 delete arg3;
18640 }
18641 return resultobj;
18642 fail:
18643 {
18644 if (temp1)
18645 delete arg1;
18646 }
18647 {
18648 if (temp2)
18649 delete arg2;
18650 }
18651 {
18652 if (temp3)
18653 delete arg3;
18654 }
18655 return NULL;
18656 }
18657
18658
18659 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18660 PyObject *obj;
18661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18662 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18663 return SWIG_Py_Void();
18664 }
18665
18666 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18667 return SWIG_Python_InitShadowInstance(args);
18668 }
18669
18670 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18671 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18672 return 1;
18673 }
18674
18675
18676 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18677 PyObject *pyobj = 0;
18678
18679 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18680 return pyobj;
18681 }
18682
18683
18684 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18685 PyObject *resultobj = 0;
18686 wxString *arg1 = 0 ;
18687 wxString *arg2 = 0 ;
18688 bool result;
18689 bool temp1 = false ;
18690 bool temp2 = false ;
18691 PyObject * obj0 = 0 ;
18692 PyObject * obj1 = 0 ;
18693 char * kwnames[] = {
18694 (char *) "mimeType",(char *) "wildcard", NULL
18695 };
18696
18697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18698 {
18699 arg1 = wxString_in_helper(obj0);
18700 if (arg1 == NULL) SWIG_fail;
18701 temp1 = true;
18702 }
18703 {
18704 arg2 = wxString_in_helper(obj1);
18705 if (arg2 == NULL) SWIG_fail;
18706 temp2 = true;
18707 }
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 {
18715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18716 }
18717 {
18718 if (temp1)
18719 delete arg1;
18720 }
18721 {
18722 if (temp2)
18723 delete arg2;
18724 }
18725 return resultobj;
18726 fail:
18727 {
18728 if (temp1)
18729 delete arg1;
18730 }
18731 {
18732 if (temp2)
18733 delete arg2;
18734 }
18735 return NULL;
18736 }
18737
18738
18739 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18740 PyObject *resultobj = 0;
18741 wxMimeTypesManager *result = 0 ;
18742
18743 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18744 {
18745 PyThreadState* __tstate = wxPyBeginAllowThreads();
18746 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18747 wxPyEndAllowThreads(__tstate);
18748 if (PyErr_Occurred()) SWIG_fail;
18749 }
18750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18751 return resultobj;
18752 fail:
18753 return NULL;
18754 }
18755
18756
18757 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18758 PyObject *resultobj = 0;
18759 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18760 int arg2 = (int) wxMAILCAP_ALL ;
18761 wxString const &arg3_defvalue = wxPyEmptyString ;
18762 wxString *arg3 = (wxString *) &arg3_defvalue ;
18763 void *argp1 = 0 ;
18764 int res1 = 0 ;
18765 int val2 ;
18766 int ecode2 = 0 ;
18767 bool temp3 = false ;
18768 PyObject * obj0 = 0 ;
18769 PyObject * obj1 = 0 ;
18770 PyObject * obj2 = 0 ;
18771 char * kwnames[] = {
18772 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18773 };
18774
18775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18777 if (!SWIG_IsOK(res1)) {
18778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18779 }
18780 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18781 if (obj1) {
18782 ecode2 = SWIG_AsVal_int(obj1, &val2);
18783 if (!SWIG_IsOK(ecode2)) {
18784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18785 }
18786 arg2 = static_cast< int >(val2);
18787 }
18788 if (obj2) {
18789 {
18790 arg3 = wxString_in_helper(obj2);
18791 if (arg3 == NULL) SWIG_fail;
18792 temp3 = true;
18793 }
18794 }
18795 {
18796 PyThreadState* __tstate = wxPyBeginAllowThreads();
18797 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18798 wxPyEndAllowThreads(__tstate);
18799 if (PyErr_Occurred()) SWIG_fail;
18800 }
18801 resultobj = SWIG_Py_Void();
18802 {
18803 if (temp3)
18804 delete arg3;
18805 }
18806 return resultobj;
18807 fail:
18808 {
18809 if (temp3)
18810 delete arg3;
18811 }
18812 return NULL;
18813 }
18814
18815
18816 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18817 PyObject *resultobj = 0;
18818 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18819 void *argp1 = 0 ;
18820 int res1 = 0 ;
18821 PyObject *swig_obj[1] ;
18822
18823 if (!args) SWIG_fail;
18824 swig_obj[0] = args;
18825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18826 if (!SWIG_IsOK(res1)) {
18827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18828 }
18829 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 (arg1)->ClearData();
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 resultobj = SWIG_Py_Void();
18837 return resultobj;
18838 fail:
18839 return NULL;
18840 }
18841
18842
18843 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj = 0;
18845 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18846 wxString *arg2 = 0 ;
18847 wxFileType *result = 0 ;
18848 void *argp1 = 0 ;
18849 int res1 = 0 ;
18850 bool temp2 = false ;
18851 PyObject * obj0 = 0 ;
18852 PyObject * obj1 = 0 ;
18853 char * kwnames[] = {
18854 (char *) "self",(char *) "ext", NULL
18855 };
18856
18857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18859 if (!SWIG_IsOK(res1)) {
18860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18861 }
18862 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18863 {
18864 arg2 = wxString_in_helper(obj1);
18865 if (arg2 == NULL) SWIG_fail;
18866 temp2 = true;
18867 }
18868 {
18869 PyThreadState* __tstate = wxPyBeginAllowThreads();
18870 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18871 wxPyEndAllowThreads(__tstate);
18872 if (PyErr_Occurred()) SWIG_fail;
18873 }
18874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18875 {
18876 if (temp2)
18877 delete arg2;
18878 }
18879 return resultobj;
18880 fail:
18881 {
18882 if (temp2)
18883 delete arg2;
18884 }
18885 return NULL;
18886 }
18887
18888
18889 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18890 PyObject *resultobj = 0;
18891 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18892 wxString *arg2 = 0 ;
18893 wxFileType *result = 0 ;
18894 void *argp1 = 0 ;
18895 int res1 = 0 ;
18896 bool temp2 = false ;
18897 PyObject * obj0 = 0 ;
18898 PyObject * obj1 = 0 ;
18899 char * kwnames[] = {
18900 (char *) "self",(char *) "mimeType", NULL
18901 };
18902
18903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18905 if (!SWIG_IsOK(res1)) {
18906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18907 }
18908 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18909 {
18910 arg2 = wxString_in_helper(obj1);
18911 if (arg2 == NULL) SWIG_fail;
18912 temp2 = true;
18913 }
18914 {
18915 PyThreadState* __tstate = wxPyBeginAllowThreads();
18916 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
18917 wxPyEndAllowThreads(__tstate);
18918 if (PyErr_Occurred()) SWIG_fail;
18919 }
18920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18921 {
18922 if (temp2)
18923 delete arg2;
18924 }
18925 return resultobj;
18926 fail:
18927 {
18928 if (temp2)
18929 delete arg2;
18930 }
18931 return NULL;
18932 }
18933
18934
18935 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18936 PyObject *resultobj = 0;
18937 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18938 wxString *arg2 = 0 ;
18939 bool arg3 = (bool) false ;
18940 bool result;
18941 void *argp1 = 0 ;
18942 int res1 = 0 ;
18943 bool temp2 = false ;
18944 bool val3 ;
18945 int ecode3 = 0 ;
18946 PyObject * obj0 = 0 ;
18947 PyObject * obj1 = 0 ;
18948 PyObject * obj2 = 0 ;
18949 char * kwnames[] = {
18950 (char *) "self",(char *) "filename",(char *) "fallback", NULL
18951 };
18952
18953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18955 if (!SWIG_IsOK(res1)) {
18956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18957 }
18958 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18959 {
18960 arg2 = wxString_in_helper(obj1);
18961 if (arg2 == NULL) SWIG_fail;
18962 temp2 = true;
18963 }
18964 if (obj2) {
18965 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18966 if (!SWIG_IsOK(ecode3)) {
18967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
18968 }
18969 arg3 = static_cast< bool >(val3);
18970 }
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 {
18978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18979 }
18980 {
18981 if (temp2)
18982 delete arg2;
18983 }
18984 return resultobj;
18985 fail:
18986 {
18987 if (temp2)
18988 delete arg2;
18989 }
18990 return NULL;
18991 }
18992
18993
18994 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18995 PyObject *resultobj = 0;
18996 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18997 wxString *arg2 = 0 ;
18998 bool result;
18999 void *argp1 = 0 ;
19000 int res1 = 0 ;
19001 bool temp2 = false ;
19002 PyObject * obj0 = 0 ;
19003 PyObject * obj1 = 0 ;
19004 char * kwnames[] = {
19005 (char *) "self",(char *) "filename", NULL
19006 };
19007
19008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) 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_ReadMimeTypes" "', 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 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19022 wxPyEndAllowThreads(__tstate);
19023 if (PyErr_Occurred()) SWIG_fail;
19024 }
19025 {
19026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19027 }
19028 {
19029 if (temp2)
19030 delete arg2;
19031 }
19032 return resultobj;
19033 fail:
19034 {
19035 if (temp2)
19036 delete arg2;
19037 }
19038 return NULL;
19039 }
19040
19041
19042 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19043 PyObject *resultobj = 0;
19044 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19045 PyObject *result = 0 ;
19046 void *argp1 = 0 ;
19047 int res1 = 0 ;
19048 PyObject *swig_obj[1] ;
19049
19050 if (!args) SWIG_fail;
19051 swig_obj[0] = args;
19052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19053 if (!SWIG_IsOK(res1)) {
19054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19055 }
19056 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19057 {
19058 PyThreadState* __tstate = wxPyBeginAllowThreads();
19059 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19060 wxPyEndAllowThreads(__tstate);
19061 if (PyErr_Occurred()) SWIG_fail;
19062 }
19063 resultobj = result;
19064 return resultobj;
19065 fail:
19066 return NULL;
19067 }
19068
19069
19070 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19071 PyObject *resultobj = 0;
19072 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19073 wxFileTypeInfo *arg2 = 0 ;
19074 void *argp1 = 0 ;
19075 int res1 = 0 ;
19076 void *argp2 = 0 ;
19077 int res2 = 0 ;
19078 PyObject * obj0 = 0 ;
19079 PyObject * obj1 = 0 ;
19080 char * kwnames[] = {
19081 (char *) "self",(char *) "ft", NULL
19082 };
19083
19084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19086 if (!SWIG_IsOK(res1)) {
19087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19088 }
19089 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19090 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19091 if (!SWIG_IsOK(res2)) {
19092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19093 }
19094 if (!argp2) {
19095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19096 }
19097 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19098 {
19099 PyThreadState* __tstate = wxPyBeginAllowThreads();
19100 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19101 wxPyEndAllowThreads(__tstate);
19102 if (PyErr_Occurred()) SWIG_fail;
19103 }
19104 resultobj = SWIG_Py_Void();
19105 return resultobj;
19106 fail:
19107 return NULL;
19108 }
19109
19110
19111 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19112 PyObject *resultobj = 0;
19113 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19114 wxFileTypeInfo *arg2 = 0 ;
19115 wxFileType *result = 0 ;
19116 void *argp1 = 0 ;
19117 int res1 = 0 ;
19118 void *argp2 = 0 ;
19119 int res2 = 0 ;
19120 PyObject * obj0 = 0 ;
19121 PyObject * obj1 = 0 ;
19122 char * kwnames[] = {
19123 (char *) "self",(char *) "ftInfo", NULL
19124 };
19125
19126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19128 if (!SWIG_IsOK(res1)) {
19129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19130 }
19131 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19132 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19133 if (!SWIG_IsOK(res2)) {
19134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19135 }
19136 if (!argp2) {
19137 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19138 }
19139 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19140 {
19141 PyThreadState* __tstate = wxPyBeginAllowThreads();
19142 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19143 wxPyEndAllowThreads(__tstate);
19144 if (PyErr_Occurred()) SWIG_fail;
19145 }
19146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19147 return resultobj;
19148 fail:
19149 return NULL;
19150 }
19151
19152
19153 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19154 PyObject *resultobj = 0;
19155 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19156 wxFileType *arg2 = (wxFileType *) 0 ;
19157 bool result;
19158 void *argp1 = 0 ;
19159 int res1 = 0 ;
19160 void *argp2 = 0 ;
19161 int res2 = 0 ;
19162 PyObject * obj0 = 0 ;
19163 PyObject * obj1 = 0 ;
19164 char * kwnames[] = {
19165 (char *) "self",(char *) "ft", NULL
19166 };
19167
19168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19172 }
19173 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19174 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19175 if (!SWIG_IsOK(res2)) {
19176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19177 }
19178 arg2 = reinterpret_cast< wxFileType * >(argp2);
19179 {
19180 PyThreadState* __tstate = wxPyBeginAllowThreads();
19181 result = (bool)(arg1)->Unassociate(arg2);
19182 wxPyEndAllowThreads(__tstate);
19183 if (PyErr_Occurred()) SWIG_fail;
19184 }
19185 {
19186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19187 }
19188 return resultobj;
19189 fail:
19190 return NULL;
19191 }
19192
19193
19194 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19195 PyObject *resultobj = 0;
19196 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19197 void *argp1 = 0 ;
19198 int res1 = 0 ;
19199 PyObject *swig_obj[1] ;
19200
19201 if (!args) SWIG_fail;
19202 swig_obj[0] = args;
19203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19204 if (!SWIG_IsOK(res1)) {
19205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19206 }
19207 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19208 {
19209 PyThreadState* __tstate = wxPyBeginAllowThreads();
19210 delete arg1;
19211
19212 wxPyEndAllowThreads(__tstate);
19213 if (PyErr_Occurred()) SWIG_fail;
19214 }
19215 resultobj = SWIG_Py_Void();
19216 return resultobj;
19217 fail:
19218 return NULL;
19219 }
19220
19221
19222 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19223 PyObject *obj;
19224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19225 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19226 return SWIG_Py_Void();
19227 }
19228
19229 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19230 return SWIG_Python_InitShadowInstance(args);
19231 }
19232
19233 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19234 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19235 return 1;
19236 }
19237
19238
19239 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19240 PyObject *pyobj = 0;
19241
19242 {
19243 #if wxUSE_UNICODE
19244 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19245 #else
19246 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19247 #endif
19248 }
19249 return pyobj;
19250 }
19251
19252
19253 SWIGINTERN int ART_MENU_set(PyObject *) {
19254 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19255 return 1;
19256 }
19257
19258
19259 SWIGINTERN PyObject *ART_MENU_get(void) {
19260 PyObject *pyobj = 0;
19261
19262 {
19263 #if wxUSE_UNICODE
19264 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19265 #else
19266 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19267 #endif
19268 }
19269 return pyobj;
19270 }
19271
19272
19273 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19274 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19275 return 1;
19276 }
19277
19278
19279 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19280 PyObject *pyobj = 0;
19281
19282 {
19283 #if wxUSE_UNICODE
19284 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19285 #else
19286 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19287 #endif
19288 }
19289 return pyobj;
19290 }
19291
19292
19293 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19294 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19295 return 1;
19296 }
19297
19298
19299 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19300 PyObject *pyobj = 0;
19301
19302 {
19303 #if wxUSE_UNICODE
19304 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19305 #else
19306 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19307 #endif
19308 }
19309 return pyobj;
19310 }
19311
19312
19313 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19314 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19315 return 1;
19316 }
19317
19318
19319 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19320 PyObject *pyobj = 0;
19321
19322 {
19323 #if wxUSE_UNICODE
19324 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19325 #else
19326 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19327 #endif
19328 }
19329 return pyobj;
19330 }
19331
19332
19333 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19334 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19335 return 1;
19336 }
19337
19338
19339 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19340 PyObject *pyobj = 0;
19341
19342 {
19343 #if wxUSE_UNICODE
19344 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19345 #else
19346 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19347 #endif
19348 }
19349 return pyobj;
19350 }
19351
19352
19353 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19354 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19355 return 1;
19356 }
19357
19358
19359 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19360 PyObject *pyobj = 0;
19361
19362 {
19363 #if wxUSE_UNICODE
19364 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19365 #else
19366 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19367 #endif
19368 }
19369 return pyobj;
19370 }
19371
19372
19373 SWIGINTERN int ART_OTHER_set(PyObject *) {
19374 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19375 return 1;
19376 }
19377
19378
19379 SWIGINTERN PyObject *ART_OTHER_get(void) {
19380 PyObject *pyobj = 0;
19381
19382 {
19383 #if wxUSE_UNICODE
19384 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19385 #else
19386 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19387 #endif
19388 }
19389 return pyobj;
19390 }
19391
19392
19393 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19394 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19395 return 1;
19396 }
19397
19398
19399 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19400 PyObject *pyobj = 0;
19401
19402 {
19403 #if wxUSE_UNICODE
19404 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19405 #else
19406 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19407 #endif
19408 }
19409 return pyobj;
19410 }
19411
19412
19413 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19414 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19415 return 1;
19416 }
19417
19418
19419 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19420 PyObject *pyobj = 0;
19421
19422 {
19423 #if wxUSE_UNICODE
19424 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19425 #else
19426 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19427 #endif
19428 }
19429 return pyobj;
19430 }
19431
19432
19433 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19434 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19435 return 1;
19436 }
19437
19438
19439 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19440 PyObject *pyobj = 0;
19441
19442 {
19443 #if wxUSE_UNICODE
19444 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19445 #else
19446 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19447 #endif
19448 }
19449 return pyobj;
19450 }
19451
19452
19453 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19454 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19455 return 1;
19456 }
19457
19458
19459 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19460 PyObject *pyobj = 0;
19461
19462 {
19463 #if wxUSE_UNICODE
19464 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19465 #else
19466 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19467 #endif
19468 }
19469 return pyobj;
19470 }
19471
19472
19473 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19474 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19475 return 1;
19476 }
19477
19478
19479 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19480 PyObject *pyobj = 0;
19481
19482 {
19483 #if wxUSE_UNICODE
19484 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19485 #else
19486 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19487 #endif
19488 }
19489 return pyobj;
19490 }
19491
19492
19493 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19494 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19495 return 1;
19496 }
19497
19498
19499 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19500 PyObject *pyobj = 0;
19501
19502 {
19503 #if wxUSE_UNICODE
19504 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19505 #else
19506 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19507 #endif
19508 }
19509 return pyobj;
19510 }
19511
19512
19513 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19514 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19515 return 1;
19516 }
19517
19518
19519 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19520 PyObject *pyobj = 0;
19521
19522 {
19523 #if wxUSE_UNICODE
19524 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19525 #else
19526 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19527 #endif
19528 }
19529 return pyobj;
19530 }
19531
19532
19533 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19534 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19535 return 1;
19536 }
19537
19538
19539 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19540 PyObject *pyobj = 0;
19541
19542 {
19543 #if wxUSE_UNICODE
19544 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19545 #else
19546 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19547 #endif
19548 }
19549 return pyobj;
19550 }
19551
19552
19553 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19554 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19555 return 1;
19556 }
19557
19558
19559 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19560 PyObject *pyobj = 0;
19561
19562 {
19563 #if wxUSE_UNICODE
19564 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19565 #else
19566 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19567 #endif
19568 }
19569 return pyobj;
19570 }
19571
19572
19573 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19574 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19575 return 1;
19576 }
19577
19578
19579 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19580 PyObject *pyobj = 0;
19581
19582 {
19583 #if wxUSE_UNICODE
19584 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19585 #else
19586 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19587 #endif
19588 }
19589 return pyobj;
19590 }
19591
19592
19593 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19594 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19595 return 1;
19596 }
19597
19598
19599 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19600 PyObject *pyobj = 0;
19601
19602 {
19603 #if wxUSE_UNICODE
19604 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19605 #else
19606 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19607 #endif
19608 }
19609 return pyobj;
19610 }
19611
19612
19613 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19614 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19615 return 1;
19616 }
19617
19618
19619 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19620 PyObject *pyobj = 0;
19621
19622 {
19623 #if wxUSE_UNICODE
19624 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19625 #else
19626 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19627 #endif
19628 }
19629 return pyobj;
19630 }
19631
19632
19633 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19634 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19635 return 1;
19636 }
19637
19638
19639 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19640 PyObject *pyobj = 0;
19641
19642 {
19643 #if wxUSE_UNICODE
19644 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19645 #else
19646 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19647 #endif
19648 }
19649 return pyobj;
19650 }
19651
19652
19653 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19654 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19655 return 1;
19656 }
19657
19658
19659 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19660 PyObject *pyobj = 0;
19661
19662 {
19663 #if wxUSE_UNICODE
19664 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19665 #else
19666 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19667 #endif
19668 }
19669 return pyobj;
19670 }
19671
19672
19673 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19674 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19675 return 1;
19676 }
19677
19678
19679 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19680 PyObject *pyobj = 0;
19681
19682 {
19683 #if wxUSE_UNICODE
19684 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19685 #else
19686 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19687 #endif
19688 }
19689 return pyobj;
19690 }
19691
19692
19693 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19694 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19695 return 1;
19696 }
19697
19698
19699 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19700 PyObject *pyobj = 0;
19701
19702 {
19703 #if wxUSE_UNICODE
19704 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19705 #else
19706 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19707 #endif
19708 }
19709 return pyobj;
19710 }
19711
19712
19713 SWIGINTERN int ART_PRINT_set(PyObject *) {
19714 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19715 return 1;
19716 }
19717
19718
19719 SWIGINTERN PyObject *ART_PRINT_get(void) {
19720 PyObject *pyobj = 0;
19721
19722 {
19723 #if wxUSE_UNICODE
19724 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19725 #else
19726 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19727 #endif
19728 }
19729 return pyobj;
19730 }
19731
19732
19733 SWIGINTERN int ART_HELP_set(PyObject *) {
19734 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19735 return 1;
19736 }
19737
19738
19739 SWIGINTERN PyObject *ART_HELP_get(void) {
19740 PyObject *pyobj = 0;
19741
19742 {
19743 #if wxUSE_UNICODE
19744 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19745 #else
19746 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19747 #endif
19748 }
19749 return pyobj;
19750 }
19751
19752
19753 SWIGINTERN int ART_TIP_set(PyObject *) {
19754 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19755 return 1;
19756 }
19757
19758
19759 SWIGINTERN PyObject *ART_TIP_get(void) {
19760 PyObject *pyobj = 0;
19761
19762 {
19763 #if wxUSE_UNICODE
19764 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19765 #else
19766 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19767 #endif
19768 }
19769 return pyobj;
19770 }
19771
19772
19773 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19774 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19775 return 1;
19776 }
19777
19778
19779 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19780 PyObject *pyobj = 0;
19781
19782 {
19783 #if wxUSE_UNICODE
19784 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19785 #else
19786 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19787 #endif
19788 }
19789 return pyobj;
19790 }
19791
19792
19793 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19794 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19795 return 1;
19796 }
19797
19798
19799 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19800 PyObject *pyobj = 0;
19801
19802 {
19803 #if wxUSE_UNICODE
19804 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19805 #else
19806 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19807 #endif
19808 }
19809 return pyobj;
19810 }
19811
19812
19813 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19814 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19815 return 1;
19816 }
19817
19818
19819 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19820 PyObject *pyobj = 0;
19821
19822 {
19823 #if wxUSE_UNICODE
19824 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19825 #else
19826 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19827 #endif
19828 }
19829 return pyobj;
19830 }
19831
19832
19833 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19834 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19835 return 1;
19836 }
19837
19838
19839 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19840 PyObject *pyobj = 0;
19841
19842 {
19843 #if wxUSE_UNICODE
19844 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19845 #else
19846 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19847 #endif
19848 }
19849 return pyobj;
19850 }
19851
19852
19853 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19854 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19855 return 1;
19856 }
19857
19858
19859 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19860 PyObject *pyobj = 0;
19861
19862 {
19863 #if wxUSE_UNICODE
19864 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19865 #else
19866 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19867 #endif
19868 }
19869 return pyobj;
19870 }
19871
19872
19873 SWIGINTERN int ART_CDROM_set(PyObject *) {
19874 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19875 return 1;
19876 }
19877
19878
19879 SWIGINTERN PyObject *ART_CDROM_get(void) {
19880 PyObject *pyobj = 0;
19881
19882 {
19883 #if wxUSE_UNICODE
19884 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19885 #else
19886 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19887 #endif
19888 }
19889 return pyobj;
19890 }
19891
19892
19893 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19894 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19895 return 1;
19896 }
19897
19898
19899 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19900 PyObject *pyobj = 0;
19901
19902 {
19903 #if wxUSE_UNICODE
19904 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19905 #else
19906 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19907 #endif
19908 }
19909 return pyobj;
19910 }
19911
19912
19913 SWIGINTERN int ART_FOLDER_set(PyObject *) {
19914 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
19915 return 1;
19916 }
19917
19918
19919 SWIGINTERN PyObject *ART_FOLDER_get(void) {
19920 PyObject *pyobj = 0;
19921
19922 {
19923 #if wxUSE_UNICODE
19924 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19925 #else
19926 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
19927 #endif
19928 }
19929 return pyobj;
19930 }
19931
19932
19933 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
19934 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
19935 return 1;
19936 }
19937
19938
19939 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
19940 PyObject *pyobj = 0;
19941
19942 {
19943 #if wxUSE_UNICODE
19944 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19945 #else
19946 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
19947 #endif
19948 }
19949 return pyobj;
19950 }
19951
19952
19953 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
19954 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
19955 return 1;
19956 }
19957
19958
19959 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
19960 PyObject *pyobj = 0;
19961
19962 {
19963 #if wxUSE_UNICODE
19964 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19965 #else
19966 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
19967 #endif
19968 }
19969 return pyobj;
19970 }
19971
19972
19973 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
19974 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
19975 return 1;
19976 }
19977
19978
19979 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
19980 PyObject *pyobj = 0;
19981
19982 {
19983 #if wxUSE_UNICODE
19984 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19985 #else
19986 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
19987 #endif
19988 }
19989 return pyobj;
19990 }
19991
19992
19993 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
19994 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
19995 return 1;
19996 }
19997
19998
19999 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20000 PyObject *pyobj = 0;
20001
20002 {
20003 #if wxUSE_UNICODE
20004 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20005 #else
20006 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20007 #endif
20008 }
20009 return pyobj;
20010 }
20011
20012
20013 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20014 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20015 return 1;
20016 }
20017
20018
20019 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20020 PyObject *pyobj = 0;
20021
20022 {
20023 #if wxUSE_UNICODE
20024 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20025 #else
20026 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20027 #endif
20028 }
20029 return pyobj;
20030 }
20031
20032
20033 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20034 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20035 return 1;
20036 }
20037
20038
20039 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20040 PyObject *pyobj = 0;
20041
20042 {
20043 #if wxUSE_UNICODE
20044 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20045 #else
20046 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20047 #endif
20048 }
20049 return pyobj;
20050 }
20051
20052
20053 SWIGINTERN int ART_ERROR_set(PyObject *) {
20054 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20055 return 1;
20056 }
20057
20058
20059 SWIGINTERN PyObject *ART_ERROR_get(void) {
20060 PyObject *pyobj = 0;
20061
20062 {
20063 #if wxUSE_UNICODE
20064 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20065 #else
20066 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20067 #endif
20068 }
20069 return pyobj;
20070 }
20071
20072
20073 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20074 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20075 return 1;
20076 }
20077
20078
20079 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20080 PyObject *pyobj = 0;
20081
20082 {
20083 #if wxUSE_UNICODE
20084 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20085 #else
20086 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20087 #endif
20088 }
20089 return pyobj;
20090 }
20091
20092
20093 SWIGINTERN int ART_WARNING_set(PyObject *) {
20094 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20095 return 1;
20096 }
20097
20098
20099 SWIGINTERN PyObject *ART_WARNING_get(void) {
20100 PyObject *pyobj = 0;
20101
20102 {
20103 #if wxUSE_UNICODE
20104 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20105 #else
20106 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20107 #endif
20108 }
20109 return pyobj;
20110 }
20111
20112
20113 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20114 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20115 return 1;
20116 }
20117
20118
20119 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20120 PyObject *pyobj = 0;
20121
20122 {
20123 #if wxUSE_UNICODE
20124 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20125 #else
20126 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20127 #endif
20128 }
20129 return pyobj;
20130 }
20131
20132
20133 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20134 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20135 return 1;
20136 }
20137
20138
20139 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20140 PyObject *pyobj = 0;
20141
20142 {
20143 #if wxUSE_UNICODE
20144 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20145 #else
20146 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20147 #endif
20148 }
20149 return pyobj;
20150 }
20151
20152
20153 SWIGINTERN int ART_COPY_set(PyObject *) {
20154 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20155 return 1;
20156 }
20157
20158
20159 SWIGINTERN PyObject *ART_COPY_get(void) {
20160 PyObject *pyobj = 0;
20161
20162 {
20163 #if wxUSE_UNICODE
20164 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20165 #else
20166 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20167 #endif
20168 }
20169 return pyobj;
20170 }
20171
20172
20173 SWIGINTERN int ART_CUT_set(PyObject *) {
20174 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20175 return 1;
20176 }
20177
20178
20179 SWIGINTERN PyObject *ART_CUT_get(void) {
20180 PyObject *pyobj = 0;
20181
20182 {
20183 #if wxUSE_UNICODE
20184 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20185 #else
20186 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20187 #endif
20188 }
20189 return pyobj;
20190 }
20191
20192
20193 SWIGINTERN int ART_PASTE_set(PyObject *) {
20194 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20195 return 1;
20196 }
20197
20198
20199 SWIGINTERN PyObject *ART_PASTE_get(void) {
20200 PyObject *pyobj = 0;
20201
20202 {
20203 #if wxUSE_UNICODE
20204 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20205 #else
20206 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20207 #endif
20208 }
20209 return pyobj;
20210 }
20211
20212
20213 SWIGINTERN int ART_DELETE_set(PyObject *) {
20214 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20215 return 1;
20216 }
20217
20218
20219 SWIGINTERN PyObject *ART_DELETE_get(void) {
20220 PyObject *pyobj = 0;
20221
20222 {
20223 #if wxUSE_UNICODE
20224 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20225 #else
20226 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20227 #endif
20228 }
20229 return pyobj;
20230 }
20231
20232
20233 SWIGINTERN int ART_NEW_set(PyObject *) {
20234 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20235 return 1;
20236 }
20237
20238
20239 SWIGINTERN PyObject *ART_NEW_get(void) {
20240 PyObject *pyobj = 0;
20241
20242 {
20243 #if wxUSE_UNICODE
20244 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20245 #else
20246 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20247 #endif
20248 }
20249 return pyobj;
20250 }
20251
20252
20253 SWIGINTERN int ART_UNDO_set(PyObject *) {
20254 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20255 return 1;
20256 }
20257
20258
20259 SWIGINTERN PyObject *ART_UNDO_get(void) {
20260 PyObject *pyobj = 0;
20261
20262 {
20263 #if wxUSE_UNICODE
20264 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20265 #else
20266 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20267 #endif
20268 }
20269 return pyobj;
20270 }
20271
20272
20273 SWIGINTERN int ART_REDO_set(PyObject *) {
20274 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20275 return 1;
20276 }
20277
20278
20279 SWIGINTERN PyObject *ART_REDO_get(void) {
20280 PyObject *pyobj = 0;
20281
20282 {
20283 #if wxUSE_UNICODE
20284 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20285 #else
20286 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20287 #endif
20288 }
20289 return pyobj;
20290 }
20291
20292
20293 SWIGINTERN int ART_QUIT_set(PyObject *) {
20294 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20295 return 1;
20296 }
20297
20298
20299 SWIGINTERN PyObject *ART_QUIT_get(void) {
20300 PyObject *pyobj = 0;
20301
20302 {
20303 #if wxUSE_UNICODE
20304 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20305 #else
20306 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20307 #endif
20308 }
20309 return pyobj;
20310 }
20311
20312
20313 SWIGINTERN int ART_FIND_set(PyObject *) {
20314 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20315 return 1;
20316 }
20317
20318
20319 SWIGINTERN PyObject *ART_FIND_get(void) {
20320 PyObject *pyobj = 0;
20321
20322 {
20323 #if wxUSE_UNICODE
20324 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20325 #else
20326 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20327 #endif
20328 }
20329 return pyobj;
20330 }
20331
20332
20333 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20334 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20335 return 1;
20336 }
20337
20338
20339 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20340 PyObject *pyobj = 0;
20341
20342 {
20343 #if wxUSE_UNICODE
20344 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20345 #else
20346 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20347 #endif
20348 }
20349 return pyobj;
20350 }
20351
20352
20353 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20354 PyObject *resultobj = 0;
20355 wxPyArtProvider *result = 0 ;
20356
20357 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20358 {
20359 if (!wxPyCheckForApp()) SWIG_fail;
20360 PyThreadState* __tstate = wxPyBeginAllowThreads();
20361 result = (wxPyArtProvider *)new wxPyArtProvider();
20362 wxPyEndAllowThreads(__tstate);
20363 if (PyErr_Occurred()) SWIG_fail;
20364 }
20365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20366 return resultobj;
20367 fail:
20368 return NULL;
20369 }
20370
20371
20372 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20373 PyObject *resultobj = 0;
20374 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20375 void *argp1 = 0 ;
20376 int res1 = 0 ;
20377 PyObject *swig_obj[1] ;
20378
20379 if (!args) SWIG_fail;
20380 swig_obj[0] = args;
20381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20382 if (!SWIG_IsOK(res1)) {
20383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20384 }
20385 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20386 {
20387 PyThreadState* __tstate = wxPyBeginAllowThreads();
20388 delete arg1;
20389
20390 wxPyEndAllowThreads(__tstate);
20391 if (PyErr_Occurred()) SWIG_fail;
20392 }
20393 resultobj = SWIG_Py_Void();
20394 return resultobj;
20395 fail:
20396 return NULL;
20397 }
20398
20399
20400 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20401 PyObject *resultobj = 0;
20402 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20403 PyObject *arg2 = (PyObject *) 0 ;
20404 PyObject *arg3 = (PyObject *) 0 ;
20405 void *argp1 = 0 ;
20406 int res1 = 0 ;
20407 PyObject * obj0 = 0 ;
20408 PyObject * obj1 = 0 ;
20409 PyObject * obj2 = 0 ;
20410 char * kwnames[] = {
20411 (char *) "self",(char *) "self",(char *) "_class", NULL
20412 };
20413
20414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20416 if (!SWIG_IsOK(res1)) {
20417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20418 }
20419 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20420 arg2 = obj1;
20421 arg3 = obj2;
20422 {
20423 PyThreadState* __tstate = wxPyBeginAllowThreads();
20424 (arg1)->_setCallbackInfo(arg2,arg3);
20425 wxPyEndAllowThreads(__tstate);
20426 if (PyErr_Occurred()) SWIG_fail;
20427 }
20428 resultobj = SWIG_Py_Void();
20429 return resultobj;
20430 fail:
20431 return NULL;
20432 }
20433
20434
20435 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20436 PyObject *resultobj = 0;
20437 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20438 int res1 = 0 ;
20439 PyObject * obj0 = 0 ;
20440 char * kwnames[] = {
20441 (char *) "provider", NULL
20442 };
20443
20444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20445 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20446 if (!SWIG_IsOK(res1)) {
20447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20448 }
20449 {
20450 PyThreadState* __tstate = wxPyBeginAllowThreads();
20451 wxPyArtProvider::Push(arg1);
20452 wxPyEndAllowThreads(__tstate);
20453 if (PyErr_Occurred()) SWIG_fail;
20454 }
20455 resultobj = SWIG_Py_Void();
20456 return resultobj;
20457 fail:
20458 return NULL;
20459 }
20460
20461
20462 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20463 PyObject *resultobj = 0;
20464 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20465 int res1 = 0 ;
20466 PyObject * obj0 = 0 ;
20467 char * kwnames[] = {
20468 (char *) "provider", NULL
20469 };
20470
20471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20472 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20473 if (!SWIG_IsOK(res1)) {
20474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20475 }
20476 {
20477 PyThreadState* __tstate = wxPyBeginAllowThreads();
20478 wxPyArtProvider::Insert(arg1);
20479 wxPyEndAllowThreads(__tstate);
20480 if (PyErr_Occurred()) SWIG_fail;
20481 }
20482 resultobj = SWIG_Py_Void();
20483 return resultobj;
20484 fail:
20485 return NULL;
20486 }
20487
20488
20489 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20490 PyObject *resultobj = 0;
20491 bool result;
20492
20493 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20494 {
20495 PyThreadState* __tstate = wxPyBeginAllowThreads();
20496 result = (bool)wxPyArtProvider::Pop();
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 {
20501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20502 }
20503 return resultobj;
20504 fail:
20505 return NULL;
20506 }
20507
20508
20509 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20510 PyObject *resultobj = 0;
20511 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20512 bool result;
20513 void *argp1 = 0 ;
20514 int res1 = 0 ;
20515 PyObject * obj0 = 0 ;
20516 char * kwnames[] = {
20517 (char *) "provider", NULL
20518 };
20519
20520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20522 if (!SWIG_IsOK(res1)) {
20523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20524 }
20525 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20526 {
20527 PyThreadState* __tstate = wxPyBeginAllowThreads();
20528 result = (bool)wxPyArtProvider::Delete(arg1);
20529 wxPyEndAllowThreads(__tstate);
20530 if (PyErr_Occurred()) SWIG_fail;
20531 }
20532 {
20533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20534 }
20535 return resultobj;
20536 fail:
20537 return NULL;
20538 }
20539
20540
20541 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20542 PyObject *resultobj = 0;
20543 wxString *arg1 = 0 ;
20544 wxString const &arg2_defvalue = wxPyART_OTHER ;
20545 wxString *arg2 = (wxString *) &arg2_defvalue ;
20546 wxSize const &arg3_defvalue = wxDefaultSize ;
20547 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20548 wxBitmap result;
20549 bool temp1 = false ;
20550 bool temp2 = false ;
20551 wxSize temp3 ;
20552 PyObject * obj0 = 0 ;
20553 PyObject * obj1 = 0 ;
20554 PyObject * obj2 = 0 ;
20555 char * kwnames[] = {
20556 (char *) "id",(char *) "client",(char *) "size", NULL
20557 };
20558
20559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20560 {
20561 arg1 = wxString_in_helper(obj0);
20562 if (arg1 == NULL) SWIG_fail;
20563 temp1 = true;
20564 }
20565 if (obj1) {
20566 {
20567 arg2 = wxString_in_helper(obj1);
20568 if (arg2 == NULL) SWIG_fail;
20569 temp2 = true;
20570 }
20571 }
20572 if (obj2) {
20573 {
20574 arg3 = &temp3;
20575 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20576 }
20577 }
20578 {
20579 if (!wxPyCheckForApp()) SWIG_fail;
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20586 {
20587 if (temp1)
20588 delete arg1;
20589 }
20590 {
20591 if (temp2)
20592 delete arg2;
20593 }
20594 return resultobj;
20595 fail:
20596 {
20597 if (temp1)
20598 delete arg1;
20599 }
20600 {
20601 if (temp2)
20602 delete arg2;
20603 }
20604 return NULL;
20605 }
20606
20607
20608 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20609 PyObject *resultobj = 0;
20610 wxString *arg1 = 0 ;
20611 wxString const &arg2_defvalue = wxPyART_OTHER ;
20612 wxString *arg2 = (wxString *) &arg2_defvalue ;
20613 wxSize const &arg3_defvalue = wxDefaultSize ;
20614 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20615 wxIcon result;
20616 bool temp1 = false ;
20617 bool temp2 = false ;
20618 wxSize temp3 ;
20619 PyObject * obj0 = 0 ;
20620 PyObject * obj1 = 0 ;
20621 PyObject * obj2 = 0 ;
20622 char * kwnames[] = {
20623 (char *) "id",(char *) "client",(char *) "size", NULL
20624 };
20625
20626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20627 {
20628 arg1 = wxString_in_helper(obj0);
20629 if (arg1 == NULL) SWIG_fail;
20630 temp1 = true;
20631 }
20632 if (obj1) {
20633 {
20634 arg2 = wxString_in_helper(obj1);
20635 if (arg2 == NULL) SWIG_fail;
20636 temp2 = true;
20637 }
20638 }
20639 if (obj2) {
20640 {
20641 arg3 = &temp3;
20642 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20643 }
20644 }
20645 {
20646 if (!wxPyCheckForApp()) SWIG_fail;
20647 PyThreadState* __tstate = wxPyBeginAllowThreads();
20648 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20649 wxPyEndAllowThreads(__tstate);
20650 if (PyErr_Occurred()) SWIG_fail;
20651 }
20652 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20653 {
20654 if (temp1)
20655 delete arg1;
20656 }
20657 {
20658 if (temp2)
20659 delete arg2;
20660 }
20661 return resultobj;
20662 fail:
20663 {
20664 if (temp1)
20665 delete arg1;
20666 }
20667 {
20668 if (temp2)
20669 delete arg2;
20670 }
20671 return NULL;
20672 }
20673
20674
20675 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20676 PyObject *resultobj = 0;
20677 wxString *arg1 = 0 ;
20678 bool arg2 = (bool) false ;
20679 wxSize result;
20680 bool temp1 = false ;
20681 bool val2 ;
20682 int ecode2 = 0 ;
20683 PyObject * obj0 = 0 ;
20684 PyObject * obj1 = 0 ;
20685 char * kwnames[] = {
20686 (char *) "client",(char *) "platform_dependent", NULL
20687 };
20688
20689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20690 {
20691 arg1 = wxString_in_helper(obj0);
20692 if (arg1 == NULL) SWIG_fail;
20693 temp1 = true;
20694 }
20695 if (obj1) {
20696 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20697 if (!SWIG_IsOK(ecode2)) {
20698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20699 }
20700 arg2 = static_cast< bool >(val2);
20701 }
20702 {
20703 PyThreadState* __tstate = wxPyBeginAllowThreads();
20704 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20705 wxPyEndAllowThreads(__tstate);
20706 if (PyErr_Occurred()) SWIG_fail;
20707 }
20708 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20709 {
20710 if (temp1)
20711 delete arg1;
20712 }
20713 return resultobj;
20714 fail:
20715 {
20716 if (temp1)
20717 delete arg1;
20718 }
20719 return NULL;
20720 }
20721
20722
20723 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20724 PyObject *resultobj = 0;
20725 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20726 void *argp1 = 0 ;
20727 int res1 = 0 ;
20728 PyObject *swig_obj[1] ;
20729
20730 if (!args) SWIG_fail;
20731 swig_obj[0] = args;
20732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20733 if (!SWIG_IsOK(res1)) {
20734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20735 }
20736 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20737 {
20738 PyThreadState* __tstate = wxPyBeginAllowThreads();
20739 wxPyArtProvider_Destroy(arg1);
20740 wxPyEndAllowThreads(__tstate);
20741 if (PyErr_Occurred()) SWIG_fail;
20742 }
20743 resultobj = SWIG_Py_Void();
20744 return resultobj;
20745 fail:
20746 return NULL;
20747 }
20748
20749
20750 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20751 PyObject *obj;
20752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20753 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20754 return SWIG_Py_Void();
20755 }
20756
20757 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20758 return SWIG_Python_InitShadowInstance(args);
20759 }
20760
20761 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20762 PyObject *resultobj = 0;
20763 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20764 void *argp1 = 0 ;
20765 int res1 = 0 ;
20766 PyObject *swig_obj[1] ;
20767
20768 if (!args) SWIG_fail;
20769 swig_obj[0] = args;
20770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20771 if (!SWIG_IsOK(res1)) {
20772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20773 }
20774 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 delete arg1;
20778
20779 wxPyEndAllowThreads(__tstate);
20780 if (PyErr_Occurred()) SWIG_fail;
20781 }
20782 resultobj = SWIG_Py_Void();
20783 return resultobj;
20784 fail:
20785 return NULL;
20786 }
20787
20788
20789 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20790 PyObject *resultobj = 0;
20791 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20792 wxConfigBase *result = 0 ;
20793 int res1 = 0 ;
20794 PyObject * obj0 = 0 ;
20795 char * kwnames[] = {
20796 (char *) "config", NULL
20797 };
20798
20799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20800 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20801 if (!SWIG_IsOK(res1)) {
20802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20803 }
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20807 wxPyEndAllowThreads(__tstate);
20808 if (PyErr_Occurred()) SWIG_fail;
20809 }
20810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20811 return resultobj;
20812 fail:
20813 return NULL;
20814 }
20815
20816
20817 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20818 PyObject *resultobj = 0;
20819 bool arg1 = (bool) true ;
20820 wxConfigBase *result = 0 ;
20821 bool val1 ;
20822 int ecode1 = 0 ;
20823 PyObject * obj0 = 0 ;
20824 char * kwnames[] = {
20825 (char *) "createOnDemand", NULL
20826 };
20827
20828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20829 if (obj0) {
20830 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20831 if (!SWIG_IsOK(ecode1)) {
20832 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20833 }
20834 arg1 = static_cast< bool >(val1);
20835 }
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20839 wxPyEndAllowThreads(__tstate);
20840 if (PyErr_Occurred()) SWIG_fail;
20841 }
20842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20843 return resultobj;
20844 fail:
20845 return NULL;
20846 }
20847
20848
20849 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20850 PyObject *resultobj = 0;
20851 wxConfigBase *result = 0 ;
20852
20853 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 result = (wxConfigBase *)wxConfigBase::Create();
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20861 return resultobj;
20862 fail:
20863 return NULL;
20864 }
20865
20866
20867 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20868 PyObject *resultobj = 0;
20869
20870 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 wxConfigBase::DontCreateOnDemand();
20874 wxPyEndAllowThreads(__tstate);
20875 if (PyErr_Occurred()) SWIG_fail;
20876 }
20877 resultobj = SWIG_Py_Void();
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20885 PyObject *resultobj = 0;
20886 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20887 wxString *arg2 = 0 ;
20888 void *argp1 = 0 ;
20889 int res1 = 0 ;
20890 bool temp2 = false ;
20891 PyObject * obj0 = 0 ;
20892 PyObject * obj1 = 0 ;
20893 char * kwnames[] = {
20894 (char *) "self",(char *) "path", NULL
20895 };
20896
20897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20899 if (!SWIG_IsOK(res1)) {
20900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20901 }
20902 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20903 {
20904 arg2 = wxString_in_helper(obj1);
20905 if (arg2 == NULL) SWIG_fail;
20906 temp2 = true;
20907 }
20908 {
20909 PyThreadState* __tstate = wxPyBeginAllowThreads();
20910 (arg1)->SetPath((wxString const &)*arg2);
20911 wxPyEndAllowThreads(__tstate);
20912 if (PyErr_Occurred()) SWIG_fail;
20913 }
20914 resultobj = SWIG_Py_Void();
20915 {
20916 if (temp2)
20917 delete arg2;
20918 }
20919 return resultobj;
20920 fail:
20921 {
20922 if (temp2)
20923 delete arg2;
20924 }
20925 return NULL;
20926 }
20927
20928
20929 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20930 PyObject *resultobj = 0;
20931 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20932 wxString *result = 0 ;
20933 void *argp1 = 0 ;
20934 int res1 = 0 ;
20935 PyObject *swig_obj[1] ;
20936
20937 if (!args) SWIG_fail;
20938 swig_obj[0] = args;
20939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20940 if (!SWIG_IsOK(res1)) {
20941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20942 }
20943 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20944 {
20945 PyThreadState* __tstate = wxPyBeginAllowThreads();
20946 {
20947 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
20948 result = (wxString *) &_result_ref;
20949 }
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 {
20954 #if wxUSE_UNICODE
20955 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
20956 #else
20957 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
20958 #endif
20959 }
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20967 PyObject *resultobj = 0;
20968 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20969 PyObject *result = 0 ;
20970 void *argp1 = 0 ;
20971 int res1 = 0 ;
20972 PyObject *swig_obj[1] ;
20973
20974 if (!args) SWIG_fail;
20975 swig_obj[0] = args;
20976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20977 if (!SWIG_IsOK(res1)) {
20978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20979 }
20980 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20981 {
20982 PyThreadState* __tstate = wxPyBeginAllowThreads();
20983 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
20984 wxPyEndAllowThreads(__tstate);
20985 if (PyErr_Occurred()) SWIG_fail;
20986 }
20987 resultobj = result;
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj = 0;
20996 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20997 long arg2 ;
20998 PyObject *result = 0 ;
20999 void *argp1 = 0 ;
21000 int res1 = 0 ;
21001 long val2 ;
21002 int ecode2 = 0 ;
21003 PyObject * obj0 = 0 ;
21004 PyObject * obj1 = 0 ;
21005 char * kwnames[] = {
21006 (char *) "self",(char *) "index", NULL
21007 };
21008
21009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21011 if (!SWIG_IsOK(res1)) {
21012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21013 }
21014 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21015 ecode2 = SWIG_AsVal_long(obj1, &val2);
21016 if (!SWIG_IsOK(ecode2)) {
21017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21018 }
21019 arg2 = static_cast< long >(val2);
21020 {
21021 PyThreadState* __tstate = wxPyBeginAllowThreads();
21022 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21023 wxPyEndAllowThreads(__tstate);
21024 if (PyErr_Occurred()) SWIG_fail;
21025 }
21026 resultobj = result;
21027 return resultobj;
21028 fail:
21029 return NULL;
21030 }
21031
21032
21033 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21034 PyObject *resultobj = 0;
21035 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21036 PyObject *result = 0 ;
21037 void *argp1 = 0 ;
21038 int res1 = 0 ;
21039 PyObject *swig_obj[1] ;
21040
21041 if (!args) SWIG_fail;
21042 swig_obj[0] = args;
21043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21044 if (!SWIG_IsOK(res1)) {
21045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21046 }
21047 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21051 wxPyEndAllowThreads(__tstate);
21052 if (PyErr_Occurred()) SWIG_fail;
21053 }
21054 resultobj = result;
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21062 PyObject *resultobj = 0;
21063 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21064 long arg2 ;
21065 PyObject *result = 0 ;
21066 void *argp1 = 0 ;
21067 int res1 = 0 ;
21068 long val2 ;
21069 int ecode2 = 0 ;
21070 PyObject * obj0 = 0 ;
21071 PyObject * obj1 = 0 ;
21072 char * kwnames[] = {
21073 (char *) "self",(char *) "index", NULL
21074 };
21075
21076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21078 if (!SWIG_IsOK(res1)) {
21079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21080 }
21081 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21082 ecode2 = SWIG_AsVal_long(obj1, &val2);
21083 if (!SWIG_IsOK(ecode2)) {
21084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21085 }
21086 arg2 = static_cast< long >(val2);
21087 {
21088 PyThreadState* __tstate = wxPyBeginAllowThreads();
21089 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21090 wxPyEndAllowThreads(__tstate);
21091 if (PyErr_Occurred()) SWIG_fail;
21092 }
21093 resultobj = result;
21094 return resultobj;
21095 fail:
21096 return NULL;
21097 }
21098
21099
21100 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21101 PyObject *resultobj = 0;
21102 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21103 bool arg2 = (bool) false ;
21104 size_t result;
21105 void *argp1 = 0 ;
21106 int res1 = 0 ;
21107 bool val2 ;
21108 int ecode2 = 0 ;
21109 PyObject * obj0 = 0 ;
21110 PyObject * obj1 = 0 ;
21111 char * kwnames[] = {
21112 (char *) "self",(char *) "recursive", NULL
21113 };
21114
21115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21117 if (!SWIG_IsOK(res1)) {
21118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21119 }
21120 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21121 if (obj1) {
21122 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21123 if (!SWIG_IsOK(ecode2)) {
21124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21125 }
21126 arg2 = static_cast< bool >(val2);
21127 }
21128 {
21129 PyThreadState* __tstate = wxPyBeginAllowThreads();
21130 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21131 wxPyEndAllowThreads(__tstate);
21132 if (PyErr_Occurred()) SWIG_fail;
21133 }
21134 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21142 PyObject *resultobj = 0;
21143 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21144 bool arg2 = (bool) false ;
21145 size_t result;
21146 void *argp1 = 0 ;
21147 int res1 = 0 ;
21148 bool val2 ;
21149 int ecode2 = 0 ;
21150 PyObject * obj0 = 0 ;
21151 PyObject * obj1 = 0 ;
21152 char * kwnames[] = {
21153 (char *) "self",(char *) "recursive", NULL
21154 };
21155
21156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21158 if (!SWIG_IsOK(res1)) {
21159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21160 }
21161 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21162 if (obj1) {
21163 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21164 if (!SWIG_IsOK(ecode2)) {
21165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21166 }
21167 arg2 = static_cast< bool >(val2);
21168 }
21169 {
21170 PyThreadState* __tstate = wxPyBeginAllowThreads();
21171 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21172 wxPyEndAllowThreads(__tstate);
21173 if (PyErr_Occurred()) SWIG_fail;
21174 }
21175 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21183 PyObject *resultobj = 0;
21184 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21185 wxString *arg2 = 0 ;
21186 bool result;
21187 void *argp1 = 0 ;
21188 int res1 = 0 ;
21189 bool temp2 = false ;
21190 PyObject * obj0 = 0 ;
21191 PyObject * obj1 = 0 ;
21192 char * kwnames[] = {
21193 (char *) "self",(char *) "name", NULL
21194 };
21195
21196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21198 if (!SWIG_IsOK(res1)) {
21199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21200 }
21201 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21202 {
21203 arg2 = wxString_in_helper(obj1);
21204 if (arg2 == NULL) SWIG_fail;
21205 temp2 = true;
21206 }
21207 {
21208 PyThreadState* __tstate = wxPyBeginAllowThreads();
21209 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21210 wxPyEndAllowThreads(__tstate);
21211 if (PyErr_Occurred()) SWIG_fail;
21212 }
21213 {
21214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21215 }
21216 {
21217 if (temp2)
21218 delete arg2;
21219 }
21220 return resultobj;
21221 fail:
21222 {
21223 if (temp2)
21224 delete arg2;
21225 }
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21231 PyObject *resultobj = 0;
21232 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21233 wxString *arg2 = 0 ;
21234 bool result;
21235 void *argp1 = 0 ;
21236 int res1 = 0 ;
21237 bool temp2 = false ;
21238 PyObject * obj0 = 0 ;
21239 PyObject * obj1 = 0 ;
21240 char * kwnames[] = {
21241 (char *) "self",(char *) "name", NULL
21242 };
21243
21244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21246 if (!SWIG_IsOK(res1)) {
21247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21248 }
21249 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21250 {
21251 arg2 = wxString_in_helper(obj1);
21252 if (arg2 == NULL) SWIG_fail;
21253 temp2 = true;
21254 }
21255 {
21256 PyThreadState* __tstate = wxPyBeginAllowThreads();
21257 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21258 wxPyEndAllowThreads(__tstate);
21259 if (PyErr_Occurred()) SWIG_fail;
21260 }
21261 {
21262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21263 }
21264 {
21265 if (temp2)
21266 delete arg2;
21267 }
21268 return resultobj;
21269 fail:
21270 {
21271 if (temp2)
21272 delete arg2;
21273 }
21274 return NULL;
21275 }
21276
21277
21278 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21279 PyObject *resultobj = 0;
21280 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21281 wxString *arg2 = 0 ;
21282 bool result;
21283 void *argp1 = 0 ;
21284 int res1 = 0 ;
21285 bool temp2 = false ;
21286 PyObject * obj0 = 0 ;
21287 PyObject * obj1 = 0 ;
21288 char * kwnames[] = {
21289 (char *) "self",(char *) "name", NULL
21290 };
21291
21292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21294 if (!SWIG_IsOK(res1)) {
21295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21296 }
21297 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21298 {
21299 arg2 = wxString_in_helper(obj1);
21300 if (arg2 == NULL) SWIG_fail;
21301 temp2 = true;
21302 }
21303 {
21304 PyThreadState* __tstate = wxPyBeginAllowThreads();
21305 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21306 wxPyEndAllowThreads(__tstate);
21307 if (PyErr_Occurred()) SWIG_fail;
21308 }
21309 {
21310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21311 }
21312 {
21313 if (temp2)
21314 delete arg2;
21315 }
21316 return resultobj;
21317 fail:
21318 {
21319 if (temp2)
21320 delete arg2;
21321 }
21322 return NULL;
21323 }
21324
21325
21326 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21327 PyObject *resultobj = 0;
21328 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21329 wxString *arg2 = 0 ;
21330 wxConfigBase::EntryType result;
21331 void *argp1 = 0 ;
21332 int res1 = 0 ;
21333 bool temp2 = false ;
21334 PyObject * obj0 = 0 ;
21335 PyObject * obj1 = 0 ;
21336 char * kwnames[] = {
21337 (char *) "self",(char *) "name", NULL
21338 };
21339
21340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21342 if (!SWIG_IsOK(res1)) {
21343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21344 }
21345 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21346 {
21347 arg2 = wxString_in_helper(obj1);
21348 if (arg2 == NULL) SWIG_fail;
21349 temp2 = true;
21350 }
21351 {
21352 PyThreadState* __tstate = wxPyBeginAllowThreads();
21353 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21354 wxPyEndAllowThreads(__tstate);
21355 if (PyErr_Occurred()) SWIG_fail;
21356 }
21357 resultobj = SWIG_From_int(static_cast< int >(result));
21358 {
21359 if (temp2)
21360 delete arg2;
21361 }
21362 return resultobj;
21363 fail:
21364 {
21365 if (temp2)
21366 delete arg2;
21367 }
21368 return NULL;
21369 }
21370
21371
21372 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21373 PyObject *resultobj = 0;
21374 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21375 wxString *arg2 = 0 ;
21376 wxString const &arg3_defvalue = wxPyEmptyString ;
21377 wxString *arg3 = (wxString *) &arg3_defvalue ;
21378 wxString result;
21379 void *argp1 = 0 ;
21380 int res1 = 0 ;
21381 bool temp2 = false ;
21382 bool temp3 = false ;
21383 PyObject * obj0 = 0 ;
21384 PyObject * obj1 = 0 ;
21385 PyObject * obj2 = 0 ;
21386 char * kwnames[] = {
21387 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21388 };
21389
21390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21392 if (!SWIG_IsOK(res1)) {
21393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21394 }
21395 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21396 {
21397 arg2 = wxString_in_helper(obj1);
21398 if (arg2 == NULL) SWIG_fail;
21399 temp2 = true;
21400 }
21401 if (obj2) {
21402 {
21403 arg3 = wxString_in_helper(obj2);
21404 if (arg3 == NULL) SWIG_fail;
21405 temp3 = true;
21406 }
21407 }
21408 {
21409 PyThreadState* __tstate = wxPyBeginAllowThreads();
21410 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21411 wxPyEndAllowThreads(__tstate);
21412 if (PyErr_Occurred()) SWIG_fail;
21413 }
21414 {
21415 #if wxUSE_UNICODE
21416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21417 #else
21418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21419 #endif
21420 }
21421 {
21422 if (temp2)
21423 delete arg2;
21424 }
21425 {
21426 if (temp3)
21427 delete arg3;
21428 }
21429 return resultobj;
21430 fail:
21431 {
21432 if (temp2)
21433 delete arg2;
21434 }
21435 {
21436 if (temp3)
21437 delete arg3;
21438 }
21439 return NULL;
21440 }
21441
21442
21443 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21444 PyObject *resultobj = 0;
21445 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21446 wxString *arg2 = 0 ;
21447 long arg3 = (long) 0 ;
21448 long result;
21449 void *argp1 = 0 ;
21450 int res1 = 0 ;
21451 bool temp2 = false ;
21452 long val3 ;
21453 int ecode3 = 0 ;
21454 PyObject * obj0 = 0 ;
21455 PyObject * obj1 = 0 ;
21456 PyObject * obj2 = 0 ;
21457 char * kwnames[] = {
21458 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21459 };
21460
21461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21463 if (!SWIG_IsOK(res1)) {
21464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21465 }
21466 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21467 {
21468 arg2 = wxString_in_helper(obj1);
21469 if (arg2 == NULL) SWIG_fail;
21470 temp2 = true;
21471 }
21472 if (obj2) {
21473 ecode3 = SWIG_AsVal_long(obj2, &val3);
21474 if (!SWIG_IsOK(ecode3)) {
21475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21476 }
21477 arg3 = static_cast< long >(val3);
21478 }
21479 {
21480 PyThreadState* __tstate = wxPyBeginAllowThreads();
21481 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21482 wxPyEndAllowThreads(__tstate);
21483 if (PyErr_Occurred()) SWIG_fail;
21484 }
21485 resultobj = SWIG_From_long(static_cast< long >(result));
21486 {
21487 if (temp2)
21488 delete arg2;
21489 }
21490 return resultobj;
21491 fail:
21492 {
21493 if (temp2)
21494 delete arg2;
21495 }
21496 return NULL;
21497 }
21498
21499
21500 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21501 PyObject *resultobj = 0;
21502 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21503 wxString *arg2 = 0 ;
21504 double arg3 = (double) 0.0 ;
21505 double result;
21506 void *argp1 = 0 ;
21507 int res1 = 0 ;
21508 bool temp2 = false ;
21509 double val3 ;
21510 int ecode3 = 0 ;
21511 PyObject * obj0 = 0 ;
21512 PyObject * obj1 = 0 ;
21513 PyObject * obj2 = 0 ;
21514 char * kwnames[] = {
21515 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21516 };
21517
21518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21520 if (!SWIG_IsOK(res1)) {
21521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21522 }
21523 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21524 {
21525 arg2 = wxString_in_helper(obj1);
21526 if (arg2 == NULL) SWIG_fail;
21527 temp2 = true;
21528 }
21529 if (obj2) {
21530 ecode3 = SWIG_AsVal_double(obj2, &val3);
21531 if (!SWIG_IsOK(ecode3)) {
21532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21533 }
21534 arg3 = static_cast< double >(val3);
21535 }
21536 {
21537 PyThreadState* __tstate = wxPyBeginAllowThreads();
21538 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21539 wxPyEndAllowThreads(__tstate);
21540 if (PyErr_Occurred()) SWIG_fail;
21541 }
21542 resultobj = SWIG_From_double(static_cast< double >(result));
21543 {
21544 if (temp2)
21545 delete arg2;
21546 }
21547 return resultobj;
21548 fail:
21549 {
21550 if (temp2)
21551 delete arg2;
21552 }
21553 return NULL;
21554 }
21555
21556
21557 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21558 PyObject *resultobj = 0;
21559 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21560 wxString *arg2 = 0 ;
21561 bool arg3 = (bool) false ;
21562 bool result;
21563 void *argp1 = 0 ;
21564 int res1 = 0 ;
21565 bool temp2 = false ;
21566 bool val3 ;
21567 int ecode3 = 0 ;
21568 PyObject * obj0 = 0 ;
21569 PyObject * obj1 = 0 ;
21570 PyObject * obj2 = 0 ;
21571 char * kwnames[] = {
21572 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21573 };
21574
21575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21577 if (!SWIG_IsOK(res1)) {
21578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21579 }
21580 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21581 {
21582 arg2 = wxString_in_helper(obj1);
21583 if (arg2 == NULL) SWIG_fail;
21584 temp2 = true;
21585 }
21586 if (obj2) {
21587 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21588 if (!SWIG_IsOK(ecode3)) {
21589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21590 }
21591 arg3 = static_cast< bool >(val3);
21592 }
21593 {
21594 PyThreadState* __tstate = wxPyBeginAllowThreads();
21595 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 {
21600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21601 }
21602 {
21603 if (temp2)
21604 delete arg2;
21605 }
21606 return resultobj;
21607 fail:
21608 {
21609 if (temp2)
21610 delete arg2;
21611 }
21612 return NULL;
21613 }
21614
21615
21616 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21617 PyObject *resultobj = 0;
21618 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21619 wxString *arg2 = 0 ;
21620 wxString *arg3 = 0 ;
21621 bool result;
21622 void *argp1 = 0 ;
21623 int res1 = 0 ;
21624 bool temp2 = false ;
21625 bool temp3 = false ;
21626 PyObject * obj0 = 0 ;
21627 PyObject * obj1 = 0 ;
21628 PyObject * obj2 = 0 ;
21629 char * kwnames[] = {
21630 (char *) "self",(char *) "key",(char *) "value", NULL
21631 };
21632
21633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21635 if (!SWIG_IsOK(res1)) {
21636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21637 }
21638 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21639 {
21640 arg2 = wxString_in_helper(obj1);
21641 if (arg2 == NULL) SWIG_fail;
21642 temp2 = true;
21643 }
21644 {
21645 arg3 = wxString_in_helper(obj2);
21646 if (arg3 == NULL) SWIG_fail;
21647 temp3 = true;
21648 }
21649 {
21650 PyThreadState* __tstate = wxPyBeginAllowThreads();
21651 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21652 wxPyEndAllowThreads(__tstate);
21653 if (PyErr_Occurred()) SWIG_fail;
21654 }
21655 {
21656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21657 }
21658 {
21659 if (temp2)
21660 delete arg2;
21661 }
21662 {
21663 if (temp3)
21664 delete arg3;
21665 }
21666 return resultobj;
21667 fail:
21668 {
21669 if (temp2)
21670 delete arg2;
21671 }
21672 {
21673 if (temp3)
21674 delete arg3;
21675 }
21676 return NULL;
21677 }
21678
21679
21680 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21681 PyObject *resultobj = 0;
21682 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21683 wxString *arg2 = 0 ;
21684 long arg3 ;
21685 bool result;
21686 void *argp1 = 0 ;
21687 int res1 = 0 ;
21688 bool temp2 = false ;
21689 long val3 ;
21690 int ecode3 = 0 ;
21691 PyObject * obj0 = 0 ;
21692 PyObject * obj1 = 0 ;
21693 PyObject * obj2 = 0 ;
21694 char * kwnames[] = {
21695 (char *) "self",(char *) "key",(char *) "value", NULL
21696 };
21697
21698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21702 }
21703 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21704 {
21705 arg2 = wxString_in_helper(obj1);
21706 if (arg2 == NULL) SWIG_fail;
21707 temp2 = true;
21708 }
21709 ecode3 = SWIG_AsVal_long(obj2, &val3);
21710 if (!SWIG_IsOK(ecode3)) {
21711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21712 }
21713 arg3 = static_cast< long >(val3);
21714 {
21715 PyThreadState* __tstate = wxPyBeginAllowThreads();
21716 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21717 wxPyEndAllowThreads(__tstate);
21718 if (PyErr_Occurred()) SWIG_fail;
21719 }
21720 {
21721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21722 }
21723 {
21724 if (temp2)
21725 delete arg2;
21726 }
21727 return resultobj;
21728 fail:
21729 {
21730 if (temp2)
21731 delete arg2;
21732 }
21733 return NULL;
21734 }
21735
21736
21737 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21738 PyObject *resultobj = 0;
21739 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21740 wxString *arg2 = 0 ;
21741 double arg3 ;
21742 bool result;
21743 void *argp1 = 0 ;
21744 int res1 = 0 ;
21745 bool temp2 = false ;
21746 double val3 ;
21747 int ecode3 = 0 ;
21748 PyObject * obj0 = 0 ;
21749 PyObject * obj1 = 0 ;
21750 PyObject * obj2 = 0 ;
21751 char * kwnames[] = {
21752 (char *) "self",(char *) "key",(char *) "value", NULL
21753 };
21754
21755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21757 if (!SWIG_IsOK(res1)) {
21758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21759 }
21760 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21761 {
21762 arg2 = wxString_in_helper(obj1);
21763 if (arg2 == NULL) SWIG_fail;
21764 temp2 = true;
21765 }
21766 ecode3 = SWIG_AsVal_double(obj2, &val3);
21767 if (!SWIG_IsOK(ecode3)) {
21768 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21769 }
21770 arg3 = static_cast< double >(val3);
21771 {
21772 PyThreadState* __tstate = wxPyBeginAllowThreads();
21773 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21774 wxPyEndAllowThreads(__tstate);
21775 if (PyErr_Occurred()) SWIG_fail;
21776 }
21777 {
21778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21779 }
21780 {
21781 if (temp2)
21782 delete arg2;
21783 }
21784 return resultobj;
21785 fail:
21786 {
21787 if (temp2)
21788 delete arg2;
21789 }
21790 return NULL;
21791 }
21792
21793
21794 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21795 PyObject *resultobj = 0;
21796 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21797 wxString *arg2 = 0 ;
21798 bool arg3 ;
21799 bool result;
21800 void *argp1 = 0 ;
21801 int res1 = 0 ;
21802 bool temp2 = false ;
21803 bool val3 ;
21804 int ecode3 = 0 ;
21805 PyObject * obj0 = 0 ;
21806 PyObject * obj1 = 0 ;
21807 PyObject * obj2 = 0 ;
21808 char * kwnames[] = {
21809 (char *) "self",(char *) "key",(char *) "value", NULL
21810 };
21811
21812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21814 if (!SWIG_IsOK(res1)) {
21815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21816 }
21817 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21818 {
21819 arg2 = wxString_in_helper(obj1);
21820 if (arg2 == NULL) SWIG_fail;
21821 temp2 = true;
21822 }
21823 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21824 if (!SWIG_IsOK(ecode3)) {
21825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21826 }
21827 arg3 = static_cast< bool >(val3);
21828 {
21829 PyThreadState* __tstate = wxPyBeginAllowThreads();
21830 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21831 wxPyEndAllowThreads(__tstate);
21832 if (PyErr_Occurred()) SWIG_fail;
21833 }
21834 {
21835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21836 }
21837 {
21838 if (temp2)
21839 delete arg2;
21840 }
21841 return resultobj;
21842 fail:
21843 {
21844 if (temp2)
21845 delete arg2;
21846 }
21847 return NULL;
21848 }
21849
21850
21851 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21852 PyObject *resultobj = 0;
21853 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21854 bool arg2 = (bool) false ;
21855 bool result;
21856 void *argp1 = 0 ;
21857 int res1 = 0 ;
21858 bool val2 ;
21859 int ecode2 = 0 ;
21860 PyObject * obj0 = 0 ;
21861 PyObject * obj1 = 0 ;
21862 char * kwnames[] = {
21863 (char *) "self",(char *) "currentOnly", NULL
21864 };
21865
21866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21868 if (!SWIG_IsOK(res1)) {
21869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21870 }
21871 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21872 if (obj1) {
21873 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21874 if (!SWIG_IsOK(ecode2)) {
21875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21876 }
21877 arg2 = static_cast< bool >(val2);
21878 }
21879 {
21880 PyThreadState* __tstate = wxPyBeginAllowThreads();
21881 result = (bool)(arg1)->Flush(arg2);
21882 wxPyEndAllowThreads(__tstate);
21883 if (PyErr_Occurred()) SWIG_fail;
21884 }
21885 {
21886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21887 }
21888 return resultobj;
21889 fail:
21890 return NULL;
21891 }
21892
21893
21894 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21895 PyObject *resultobj = 0;
21896 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21897 wxString *arg2 = 0 ;
21898 wxString *arg3 = 0 ;
21899 bool result;
21900 void *argp1 = 0 ;
21901 int res1 = 0 ;
21902 bool temp2 = false ;
21903 bool temp3 = false ;
21904 PyObject * obj0 = 0 ;
21905 PyObject * obj1 = 0 ;
21906 PyObject * obj2 = 0 ;
21907 char * kwnames[] = {
21908 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21909 };
21910
21911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21913 if (!SWIG_IsOK(res1)) {
21914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21915 }
21916 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21917 {
21918 arg2 = wxString_in_helper(obj1);
21919 if (arg2 == NULL) SWIG_fail;
21920 temp2 = true;
21921 }
21922 {
21923 arg3 = wxString_in_helper(obj2);
21924 if (arg3 == NULL) SWIG_fail;
21925 temp3 = true;
21926 }
21927 {
21928 PyThreadState* __tstate = wxPyBeginAllowThreads();
21929 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
21930 wxPyEndAllowThreads(__tstate);
21931 if (PyErr_Occurred()) SWIG_fail;
21932 }
21933 {
21934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21935 }
21936 {
21937 if (temp2)
21938 delete arg2;
21939 }
21940 {
21941 if (temp3)
21942 delete arg3;
21943 }
21944 return resultobj;
21945 fail:
21946 {
21947 if (temp2)
21948 delete arg2;
21949 }
21950 {
21951 if (temp3)
21952 delete arg3;
21953 }
21954 return NULL;
21955 }
21956
21957
21958 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21959 PyObject *resultobj = 0;
21960 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21961 wxString *arg2 = 0 ;
21962 wxString *arg3 = 0 ;
21963 bool result;
21964 void *argp1 = 0 ;
21965 int res1 = 0 ;
21966 bool temp2 = false ;
21967 bool temp3 = false ;
21968 PyObject * obj0 = 0 ;
21969 PyObject * obj1 = 0 ;
21970 PyObject * obj2 = 0 ;
21971 char * kwnames[] = {
21972 (char *) "self",(char *) "oldName",(char *) "newName", NULL
21973 };
21974
21975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21977 if (!SWIG_IsOK(res1)) {
21978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21979 }
21980 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21981 {
21982 arg2 = wxString_in_helper(obj1);
21983 if (arg2 == NULL) SWIG_fail;
21984 temp2 = true;
21985 }
21986 {
21987 arg3 = wxString_in_helper(obj2);
21988 if (arg3 == NULL) SWIG_fail;
21989 temp3 = true;
21990 }
21991 {
21992 PyThreadState* __tstate = wxPyBeginAllowThreads();
21993 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
21994 wxPyEndAllowThreads(__tstate);
21995 if (PyErr_Occurred()) SWIG_fail;
21996 }
21997 {
21998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21999 }
22000 {
22001 if (temp2)
22002 delete arg2;
22003 }
22004 {
22005 if (temp3)
22006 delete arg3;
22007 }
22008 return resultobj;
22009 fail:
22010 {
22011 if (temp2)
22012 delete arg2;
22013 }
22014 {
22015 if (temp3)
22016 delete arg3;
22017 }
22018 return NULL;
22019 }
22020
22021
22022 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22023 PyObject *resultobj = 0;
22024 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22025 wxString *arg2 = 0 ;
22026 bool arg3 = (bool) true ;
22027 bool result;
22028 void *argp1 = 0 ;
22029 int res1 = 0 ;
22030 bool temp2 = false ;
22031 bool val3 ;
22032 int ecode3 = 0 ;
22033 PyObject * obj0 = 0 ;
22034 PyObject * obj1 = 0 ;
22035 PyObject * obj2 = 0 ;
22036 char * kwnames[] = {
22037 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22038 };
22039
22040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22042 if (!SWIG_IsOK(res1)) {
22043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22044 }
22045 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22046 {
22047 arg2 = wxString_in_helper(obj1);
22048 if (arg2 == NULL) SWIG_fail;
22049 temp2 = true;
22050 }
22051 if (obj2) {
22052 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22053 if (!SWIG_IsOK(ecode3)) {
22054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22055 }
22056 arg3 = static_cast< bool >(val3);
22057 }
22058 {
22059 PyThreadState* __tstate = wxPyBeginAllowThreads();
22060 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22061 wxPyEndAllowThreads(__tstate);
22062 if (PyErr_Occurred()) SWIG_fail;
22063 }
22064 {
22065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22066 }
22067 {
22068 if (temp2)
22069 delete arg2;
22070 }
22071 return resultobj;
22072 fail:
22073 {
22074 if (temp2)
22075 delete arg2;
22076 }
22077 return NULL;
22078 }
22079
22080
22081 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22082 PyObject *resultobj = 0;
22083 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22084 wxString *arg2 = 0 ;
22085 bool result;
22086 void *argp1 = 0 ;
22087 int res1 = 0 ;
22088 bool temp2 = false ;
22089 PyObject * obj0 = 0 ;
22090 PyObject * obj1 = 0 ;
22091 char * kwnames[] = {
22092 (char *) "self",(char *) "key", NULL
22093 };
22094
22095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) 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_DeleteGroup" "', 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 {
22107 PyThreadState* __tstate = wxPyBeginAllowThreads();
22108 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22109 wxPyEndAllowThreads(__tstate);
22110 if (PyErr_Occurred()) SWIG_fail;
22111 }
22112 {
22113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22114 }
22115 {
22116 if (temp2)
22117 delete arg2;
22118 }
22119 return resultobj;
22120 fail:
22121 {
22122 if (temp2)
22123 delete arg2;
22124 }
22125 return NULL;
22126 }
22127
22128
22129 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22130 PyObject *resultobj = 0;
22131 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22132 bool result;
22133 void *argp1 = 0 ;
22134 int res1 = 0 ;
22135 PyObject *swig_obj[1] ;
22136
22137 if (!args) SWIG_fail;
22138 swig_obj[0] = args;
22139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22140 if (!SWIG_IsOK(res1)) {
22141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22142 }
22143 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22144 {
22145 PyThreadState* __tstate = wxPyBeginAllowThreads();
22146 result = (bool)(arg1)->DeleteAll();
22147 wxPyEndAllowThreads(__tstate);
22148 if (PyErr_Occurred()) SWIG_fail;
22149 }
22150 {
22151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22152 }
22153 return resultobj;
22154 fail:
22155 return NULL;
22156 }
22157
22158
22159 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22160 PyObject *resultobj = 0;
22161 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22162 bool arg2 = (bool) true ;
22163 void *argp1 = 0 ;
22164 int res1 = 0 ;
22165 bool val2 ;
22166 int ecode2 = 0 ;
22167 PyObject * obj0 = 0 ;
22168 PyObject * obj1 = 0 ;
22169 char * kwnames[] = {
22170 (char *) "self",(char *) "doIt", NULL
22171 };
22172
22173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22175 if (!SWIG_IsOK(res1)) {
22176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22177 }
22178 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22179 if (obj1) {
22180 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22181 if (!SWIG_IsOK(ecode2)) {
22182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22183 }
22184 arg2 = static_cast< bool >(val2);
22185 }
22186 {
22187 PyThreadState* __tstate = wxPyBeginAllowThreads();
22188 (arg1)->SetExpandEnvVars(arg2);
22189 wxPyEndAllowThreads(__tstate);
22190 if (PyErr_Occurred()) SWIG_fail;
22191 }
22192 resultobj = SWIG_Py_Void();
22193 return resultobj;
22194 fail:
22195 return NULL;
22196 }
22197
22198
22199 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22200 PyObject *resultobj = 0;
22201 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22202 bool result;
22203 void *argp1 = 0 ;
22204 int res1 = 0 ;
22205 PyObject *swig_obj[1] ;
22206
22207 if (!args) SWIG_fail;
22208 swig_obj[0] = args;
22209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22210 if (!SWIG_IsOK(res1)) {
22211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22212 }
22213 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22214 {
22215 PyThreadState* __tstate = wxPyBeginAllowThreads();
22216 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22217 wxPyEndAllowThreads(__tstate);
22218 if (PyErr_Occurred()) SWIG_fail;
22219 }
22220 {
22221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22222 }
22223 return resultobj;
22224 fail:
22225 return NULL;
22226 }
22227
22228
22229 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22230 PyObject *resultobj = 0;
22231 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22232 bool arg2 = (bool) true ;
22233 void *argp1 = 0 ;
22234 int res1 = 0 ;
22235 bool val2 ;
22236 int ecode2 = 0 ;
22237 PyObject * obj0 = 0 ;
22238 PyObject * obj1 = 0 ;
22239 char * kwnames[] = {
22240 (char *) "self",(char *) "doIt", NULL
22241 };
22242
22243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22245 if (!SWIG_IsOK(res1)) {
22246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22247 }
22248 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22249 if (obj1) {
22250 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22251 if (!SWIG_IsOK(ecode2)) {
22252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22253 }
22254 arg2 = static_cast< bool >(val2);
22255 }
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 (arg1)->SetRecordDefaults(arg2);
22259 wxPyEndAllowThreads(__tstate);
22260 if (PyErr_Occurred()) SWIG_fail;
22261 }
22262 resultobj = SWIG_Py_Void();
22263 return resultobj;
22264 fail:
22265 return NULL;
22266 }
22267
22268
22269 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22270 PyObject *resultobj = 0;
22271 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22272 bool result;
22273 void *argp1 = 0 ;
22274 int res1 = 0 ;
22275 PyObject *swig_obj[1] ;
22276
22277 if (!args) SWIG_fail;
22278 swig_obj[0] = args;
22279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22280 if (!SWIG_IsOK(res1)) {
22281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22282 }
22283 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22284 {
22285 PyThreadState* __tstate = wxPyBeginAllowThreads();
22286 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22287 wxPyEndAllowThreads(__tstate);
22288 if (PyErr_Occurred()) SWIG_fail;
22289 }
22290 {
22291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22292 }
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22300 PyObject *resultobj = 0;
22301 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22302 wxString *arg2 = 0 ;
22303 wxString result;
22304 void *argp1 = 0 ;
22305 int res1 = 0 ;
22306 bool temp2 = false ;
22307 PyObject * obj0 = 0 ;
22308 PyObject * obj1 = 0 ;
22309 char * kwnames[] = {
22310 (char *) "self",(char *) "str", NULL
22311 };
22312
22313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22315 if (!SWIG_IsOK(res1)) {
22316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22317 }
22318 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22319 {
22320 arg2 = wxString_in_helper(obj1);
22321 if (arg2 == NULL) SWIG_fail;
22322 temp2 = true;
22323 }
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22327 wxPyEndAllowThreads(__tstate);
22328 if (PyErr_Occurred()) SWIG_fail;
22329 }
22330 {
22331 #if wxUSE_UNICODE
22332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22333 #else
22334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22335 #endif
22336 }
22337 {
22338 if (temp2)
22339 delete arg2;
22340 }
22341 return resultobj;
22342 fail:
22343 {
22344 if (temp2)
22345 delete arg2;
22346 }
22347 return NULL;
22348 }
22349
22350
22351 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22352 PyObject *resultobj = 0;
22353 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22354 wxString result;
22355 void *argp1 = 0 ;
22356 int res1 = 0 ;
22357 PyObject *swig_obj[1] ;
22358
22359 if (!args) SWIG_fail;
22360 swig_obj[0] = args;
22361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22362 if (!SWIG_IsOK(res1)) {
22363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22364 }
22365 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22366 {
22367 PyThreadState* __tstate = wxPyBeginAllowThreads();
22368 result = ((wxConfigBase const *)arg1)->GetAppName();
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 {
22373 #if wxUSE_UNICODE
22374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22375 #else
22376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22377 #endif
22378 }
22379 return resultobj;
22380 fail:
22381 return NULL;
22382 }
22383
22384
22385 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22386 PyObject *resultobj = 0;
22387 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22388 wxString result;
22389 void *argp1 = 0 ;
22390 int res1 = 0 ;
22391 PyObject *swig_obj[1] ;
22392
22393 if (!args) SWIG_fail;
22394 swig_obj[0] = args;
22395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22396 if (!SWIG_IsOK(res1)) {
22397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22398 }
22399 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22400 {
22401 PyThreadState* __tstate = wxPyBeginAllowThreads();
22402 result = ((wxConfigBase const *)arg1)->GetVendorName();
22403 wxPyEndAllowThreads(__tstate);
22404 if (PyErr_Occurred()) SWIG_fail;
22405 }
22406 {
22407 #if wxUSE_UNICODE
22408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22409 #else
22410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22411 #endif
22412 }
22413 return resultobj;
22414 fail:
22415 return NULL;
22416 }
22417
22418
22419 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22420 PyObject *resultobj = 0;
22421 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22422 wxString *arg2 = 0 ;
22423 void *argp1 = 0 ;
22424 int res1 = 0 ;
22425 bool temp2 = false ;
22426 PyObject * obj0 = 0 ;
22427 PyObject * obj1 = 0 ;
22428 char * kwnames[] = {
22429 (char *) "self",(char *) "appName", NULL
22430 };
22431
22432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22434 if (!SWIG_IsOK(res1)) {
22435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22436 }
22437 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22438 {
22439 arg2 = wxString_in_helper(obj1);
22440 if (arg2 == NULL) SWIG_fail;
22441 temp2 = true;
22442 }
22443 {
22444 PyThreadState* __tstate = wxPyBeginAllowThreads();
22445 (arg1)->SetAppName((wxString const &)*arg2);
22446 wxPyEndAllowThreads(__tstate);
22447 if (PyErr_Occurred()) SWIG_fail;
22448 }
22449 resultobj = SWIG_Py_Void();
22450 {
22451 if (temp2)
22452 delete arg2;
22453 }
22454 return resultobj;
22455 fail:
22456 {
22457 if (temp2)
22458 delete arg2;
22459 }
22460 return NULL;
22461 }
22462
22463
22464 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22465 PyObject *resultobj = 0;
22466 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22467 wxString *arg2 = 0 ;
22468 void *argp1 = 0 ;
22469 int res1 = 0 ;
22470 bool temp2 = false ;
22471 PyObject * obj0 = 0 ;
22472 PyObject * obj1 = 0 ;
22473 char * kwnames[] = {
22474 (char *) "self",(char *) "vendorName", NULL
22475 };
22476
22477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22479 if (!SWIG_IsOK(res1)) {
22480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22481 }
22482 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22483 {
22484 arg2 = wxString_in_helper(obj1);
22485 if (arg2 == NULL) SWIG_fail;
22486 temp2 = true;
22487 }
22488 {
22489 PyThreadState* __tstate = wxPyBeginAllowThreads();
22490 (arg1)->SetVendorName((wxString const &)*arg2);
22491 wxPyEndAllowThreads(__tstate);
22492 if (PyErr_Occurred()) SWIG_fail;
22493 }
22494 resultobj = SWIG_Py_Void();
22495 {
22496 if (temp2)
22497 delete arg2;
22498 }
22499 return resultobj;
22500 fail:
22501 {
22502 if (temp2)
22503 delete arg2;
22504 }
22505 return NULL;
22506 }
22507
22508
22509 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22510 PyObject *resultobj = 0;
22511 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22512 long arg2 ;
22513 void *argp1 = 0 ;
22514 int res1 = 0 ;
22515 long val2 ;
22516 int ecode2 = 0 ;
22517 PyObject * obj0 = 0 ;
22518 PyObject * obj1 = 0 ;
22519 char * kwnames[] = {
22520 (char *) "self",(char *) "style", NULL
22521 };
22522
22523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22525 if (!SWIG_IsOK(res1)) {
22526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22527 }
22528 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22529 ecode2 = SWIG_AsVal_long(obj1, &val2);
22530 if (!SWIG_IsOK(ecode2)) {
22531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22532 }
22533 arg2 = static_cast< long >(val2);
22534 {
22535 PyThreadState* __tstate = wxPyBeginAllowThreads();
22536 (arg1)->SetStyle(arg2);
22537 wxPyEndAllowThreads(__tstate);
22538 if (PyErr_Occurred()) SWIG_fail;
22539 }
22540 resultobj = SWIG_Py_Void();
22541 return resultobj;
22542 fail:
22543 return NULL;
22544 }
22545
22546
22547 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22548 PyObject *resultobj = 0;
22549 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22550 long result;
22551 void *argp1 = 0 ;
22552 int res1 = 0 ;
22553 PyObject *swig_obj[1] ;
22554
22555 if (!args) SWIG_fail;
22556 swig_obj[0] = args;
22557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22558 if (!SWIG_IsOK(res1)) {
22559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22560 }
22561 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22562 {
22563 PyThreadState* __tstate = wxPyBeginAllowThreads();
22564 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22565 wxPyEndAllowThreads(__tstate);
22566 if (PyErr_Occurred()) SWIG_fail;
22567 }
22568 resultobj = SWIG_From_long(static_cast< long >(result));
22569 return resultobj;
22570 fail:
22571 return NULL;
22572 }
22573
22574
22575 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22576 PyObject *obj;
22577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22578 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22579 return SWIG_Py_Void();
22580 }
22581
22582 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22583 PyObject *resultobj = 0;
22584 wxString const &arg1_defvalue = wxPyEmptyString ;
22585 wxString *arg1 = (wxString *) &arg1_defvalue ;
22586 wxString const &arg2_defvalue = wxPyEmptyString ;
22587 wxString *arg2 = (wxString *) &arg2_defvalue ;
22588 wxString const &arg3_defvalue = wxPyEmptyString ;
22589 wxString *arg3 = (wxString *) &arg3_defvalue ;
22590 wxString const &arg4_defvalue = wxPyEmptyString ;
22591 wxString *arg4 = (wxString *) &arg4_defvalue ;
22592 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22593 wxConfig *result = 0 ;
22594 bool temp1 = false ;
22595 bool temp2 = false ;
22596 bool temp3 = false ;
22597 bool temp4 = false ;
22598 long val5 ;
22599 int ecode5 = 0 ;
22600 PyObject * obj0 = 0 ;
22601 PyObject * obj1 = 0 ;
22602 PyObject * obj2 = 0 ;
22603 PyObject * obj3 = 0 ;
22604 PyObject * obj4 = 0 ;
22605 char * kwnames[] = {
22606 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22607 };
22608
22609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22610 if (obj0) {
22611 {
22612 arg1 = wxString_in_helper(obj0);
22613 if (arg1 == NULL) SWIG_fail;
22614 temp1 = true;
22615 }
22616 }
22617 if (obj1) {
22618 {
22619 arg2 = wxString_in_helper(obj1);
22620 if (arg2 == NULL) SWIG_fail;
22621 temp2 = true;
22622 }
22623 }
22624 if (obj2) {
22625 {
22626 arg3 = wxString_in_helper(obj2);
22627 if (arg3 == NULL) SWIG_fail;
22628 temp3 = true;
22629 }
22630 }
22631 if (obj3) {
22632 {
22633 arg4 = wxString_in_helper(obj3);
22634 if (arg4 == NULL) SWIG_fail;
22635 temp4 = true;
22636 }
22637 }
22638 if (obj4) {
22639 ecode5 = SWIG_AsVal_long(obj4, &val5);
22640 if (!SWIG_IsOK(ecode5)) {
22641 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22642 }
22643 arg5 = static_cast< long >(val5);
22644 }
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22652 {
22653 if (temp1)
22654 delete arg1;
22655 }
22656 {
22657 if (temp2)
22658 delete arg2;
22659 }
22660 {
22661 if (temp3)
22662 delete arg3;
22663 }
22664 {
22665 if (temp4)
22666 delete arg4;
22667 }
22668 return resultobj;
22669 fail:
22670 {
22671 if (temp1)
22672 delete arg1;
22673 }
22674 {
22675 if (temp2)
22676 delete arg2;
22677 }
22678 {
22679 if (temp3)
22680 delete arg3;
22681 }
22682 {
22683 if (temp4)
22684 delete arg4;
22685 }
22686 return NULL;
22687 }
22688
22689
22690 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22691 PyObject *resultobj = 0;
22692 wxConfig *arg1 = (wxConfig *) 0 ;
22693 void *argp1 = 0 ;
22694 int res1 = 0 ;
22695 PyObject *swig_obj[1] ;
22696
22697 if (!args) SWIG_fail;
22698 swig_obj[0] = args;
22699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22700 if (!SWIG_IsOK(res1)) {
22701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22702 }
22703 arg1 = reinterpret_cast< wxConfig * >(argp1);
22704 {
22705 PyThreadState* __tstate = wxPyBeginAllowThreads();
22706 delete arg1;
22707
22708 wxPyEndAllowThreads(__tstate);
22709 if (PyErr_Occurred()) SWIG_fail;
22710 }
22711 resultobj = SWIG_Py_Void();
22712 return resultobj;
22713 fail:
22714 return NULL;
22715 }
22716
22717
22718 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22719 PyObject *obj;
22720 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22721 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22722 return SWIG_Py_Void();
22723 }
22724
22725 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22726 return SWIG_Python_InitShadowInstance(args);
22727 }
22728
22729 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22730 PyObject *resultobj = 0;
22731 wxString const &arg1_defvalue = wxPyEmptyString ;
22732 wxString *arg1 = (wxString *) &arg1_defvalue ;
22733 wxString const &arg2_defvalue = wxPyEmptyString ;
22734 wxString *arg2 = (wxString *) &arg2_defvalue ;
22735 wxString const &arg3_defvalue = wxPyEmptyString ;
22736 wxString *arg3 = (wxString *) &arg3_defvalue ;
22737 wxString const &arg4_defvalue = wxPyEmptyString ;
22738 wxString *arg4 = (wxString *) &arg4_defvalue ;
22739 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22740 wxFileConfig *result = 0 ;
22741 bool temp1 = false ;
22742 bool temp2 = false ;
22743 bool temp3 = false ;
22744 bool temp4 = false ;
22745 long val5 ;
22746 int ecode5 = 0 ;
22747 PyObject * obj0 = 0 ;
22748 PyObject * obj1 = 0 ;
22749 PyObject * obj2 = 0 ;
22750 PyObject * obj3 = 0 ;
22751 PyObject * obj4 = 0 ;
22752 char * kwnames[] = {
22753 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22754 };
22755
22756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22757 if (obj0) {
22758 {
22759 arg1 = wxString_in_helper(obj0);
22760 if (arg1 == NULL) SWIG_fail;
22761 temp1 = true;
22762 }
22763 }
22764 if (obj1) {
22765 {
22766 arg2 = wxString_in_helper(obj1);
22767 if (arg2 == NULL) SWIG_fail;
22768 temp2 = true;
22769 }
22770 }
22771 if (obj2) {
22772 {
22773 arg3 = wxString_in_helper(obj2);
22774 if (arg3 == NULL) SWIG_fail;
22775 temp3 = true;
22776 }
22777 }
22778 if (obj3) {
22779 {
22780 arg4 = wxString_in_helper(obj3);
22781 if (arg4 == NULL) SWIG_fail;
22782 temp4 = true;
22783 }
22784 }
22785 if (obj4) {
22786 ecode5 = SWIG_AsVal_long(obj4, &val5);
22787 if (!SWIG_IsOK(ecode5)) {
22788 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22789 }
22790 arg5 = static_cast< long >(val5);
22791 }
22792 {
22793 PyThreadState* __tstate = wxPyBeginAllowThreads();
22794 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22795 wxPyEndAllowThreads(__tstate);
22796 if (PyErr_Occurred()) SWIG_fail;
22797 }
22798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22799 {
22800 if (temp1)
22801 delete arg1;
22802 }
22803 {
22804 if (temp2)
22805 delete arg2;
22806 }
22807 {
22808 if (temp3)
22809 delete arg3;
22810 }
22811 {
22812 if (temp4)
22813 delete arg4;
22814 }
22815 return resultobj;
22816 fail:
22817 {
22818 if (temp1)
22819 delete arg1;
22820 }
22821 {
22822 if (temp2)
22823 delete arg2;
22824 }
22825 {
22826 if (temp3)
22827 delete arg3;
22828 }
22829 {
22830 if (temp4)
22831 delete arg4;
22832 }
22833 return NULL;
22834 }
22835
22836
22837 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22838 PyObject *resultobj = 0;
22839 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22840 void *argp1 = 0 ;
22841 int res1 = 0 ;
22842 PyObject *swig_obj[1] ;
22843
22844 if (!args) SWIG_fail;
22845 swig_obj[0] = args;
22846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22847 if (!SWIG_IsOK(res1)) {
22848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22849 }
22850 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22851 {
22852 PyThreadState* __tstate = wxPyBeginAllowThreads();
22853 delete arg1;
22854
22855 wxPyEndAllowThreads(__tstate);
22856 if (PyErr_Occurred()) SWIG_fail;
22857 }
22858 resultobj = SWIG_Py_Void();
22859 return resultobj;
22860 fail:
22861 return NULL;
22862 }
22863
22864
22865 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22866 PyObject *obj;
22867 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22868 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22869 return SWIG_Py_Void();
22870 }
22871
22872 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22873 return SWIG_Python_InitShadowInstance(args);
22874 }
22875
22876 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22877 PyObject *resultobj = 0;
22878 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22879 wxString *arg2 = 0 ;
22880 wxConfigPathChanger *result = 0 ;
22881 void *argp1 = 0 ;
22882 int res1 = 0 ;
22883 bool temp2 = false ;
22884 PyObject * obj0 = 0 ;
22885 PyObject * obj1 = 0 ;
22886 char * kwnames[] = {
22887 (char *) "config",(char *) "entry", NULL
22888 };
22889
22890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22892 if (!SWIG_IsOK(res1)) {
22893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22894 }
22895 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22896 {
22897 arg2 = wxString_in_helper(obj1);
22898 if (arg2 == NULL) SWIG_fail;
22899 temp2 = true;
22900 }
22901 {
22902 PyThreadState* __tstate = wxPyBeginAllowThreads();
22903 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22904 wxPyEndAllowThreads(__tstate);
22905 if (PyErr_Occurred()) SWIG_fail;
22906 }
22907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
22908 {
22909 if (temp2)
22910 delete arg2;
22911 }
22912 return resultobj;
22913 fail:
22914 {
22915 if (temp2)
22916 delete arg2;
22917 }
22918 return NULL;
22919 }
22920
22921
22922 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22923 PyObject *resultobj = 0;
22924 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22925 void *argp1 = 0 ;
22926 int res1 = 0 ;
22927 PyObject *swig_obj[1] ;
22928
22929 if (!args) SWIG_fail;
22930 swig_obj[0] = args;
22931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
22932 if (!SWIG_IsOK(res1)) {
22933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
22934 }
22935 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22936 {
22937 PyThreadState* __tstate = wxPyBeginAllowThreads();
22938 delete arg1;
22939
22940 wxPyEndAllowThreads(__tstate);
22941 if (PyErr_Occurred()) SWIG_fail;
22942 }
22943 resultobj = SWIG_Py_Void();
22944 return resultobj;
22945 fail:
22946 return NULL;
22947 }
22948
22949
22950 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22951 PyObject *resultobj = 0;
22952 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
22953 wxString *result = 0 ;
22954 void *argp1 = 0 ;
22955 int res1 = 0 ;
22956 PyObject *swig_obj[1] ;
22957
22958 if (!args) SWIG_fail;
22959 swig_obj[0] = args;
22960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
22961 if (!SWIG_IsOK(res1)) {
22962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
22963 }
22964 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
22965 {
22966 PyThreadState* __tstate = wxPyBeginAllowThreads();
22967 {
22968 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
22969 result = (wxString *) &_result_ref;
22970 }
22971 wxPyEndAllowThreads(__tstate);
22972 if (PyErr_Occurred()) SWIG_fail;
22973 }
22974 {
22975 #if wxUSE_UNICODE
22976 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22977 #else
22978 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22979 #endif
22980 }
22981 return resultobj;
22982 fail:
22983 return NULL;
22984 }
22985
22986
22987 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22988 PyObject *obj;
22989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22990 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
22991 return SWIG_Py_Void();
22992 }
22993
22994 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22995 return SWIG_Python_InitShadowInstance(args);
22996 }
22997
22998 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22999 PyObject *resultobj = 0;
23000 wxString *arg1 = 0 ;
23001 wxString result;
23002 bool temp1 = false ;
23003 PyObject * obj0 = 0 ;
23004 char * kwnames[] = {
23005 (char *) "sz", NULL
23006 };
23007
23008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23009 {
23010 arg1 = wxString_in_helper(obj0);
23011 if (arg1 == NULL) SWIG_fail;
23012 temp1 = true;
23013 }
23014 {
23015 PyThreadState* __tstate = wxPyBeginAllowThreads();
23016 result = wxExpandEnvVars((wxString const &)*arg1);
23017 wxPyEndAllowThreads(__tstate);
23018 if (PyErr_Occurred()) SWIG_fail;
23019 }
23020 {
23021 #if wxUSE_UNICODE
23022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23023 #else
23024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23025 #endif
23026 }
23027 {
23028 if (temp1)
23029 delete arg1;
23030 }
23031 return resultobj;
23032 fail:
23033 {
23034 if (temp1)
23035 delete arg1;
23036 }
23037 return NULL;
23038 }
23039
23040
23041 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23042 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23043 return 1;
23044 }
23045
23046
23047 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23048 PyObject *pyobj = 0;
23049
23050 {
23051 #if wxUSE_UNICODE
23052 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23053 #else
23054 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23055 #endif
23056 }
23057 return pyobj;
23058 }
23059
23060
23061 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23062 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23063 return 1;
23064 }
23065
23066
23067 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23068 PyObject *pyobj = 0;
23069
23070 {
23071 #if wxUSE_UNICODE
23072 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23073 #else
23074 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23075 #endif
23076 }
23077 return pyobj;
23078 }
23079
23080
23081 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23082 PyObject *resultobj = 0;
23083 wxDateTime::Country arg1 ;
23084 int val1 ;
23085 int ecode1 = 0 ;
23086 PyObject * obj0 = 0 ;
23087 char * kwnames[] = {
23088 (char *) "country", NULL
23089 };
23090
23091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23092 ecode1 = SWIG_AsVal_int(obj0, &val1);
23093 if (!SWIG_IsOK(ecode1)) {
23094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23095 }
23096 arg1 = static_cast< wxDateTime::Country >(val1);
23097 {
23098 PyThreadState* __tstate = wxPyBeginAllowThreads();
23099 wxDateTime::SetCountry(arg1);
23100 wxPyEndAllowThreads(__tstate);
23101 if (PyErr_Occurred()) SWIG_fail;
23102 }
23103 resultobj = SWIG_Py_Void();
23104 return resultobj;
23105 fail:
23106 return NULL;
23107 }
23108
23109
23110 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23111 PyObject *resultobj = 0;
23112 wxDateTime::Country result;
23113
23114 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23115 {
23116 PyThreadState* __tstate = wxPyBeginAllowThreads();
23117 result = (wxDateTime::Country)wxDateTime::GetCountry();
23118 wxPyEndAllowThreads(__tstate);
23119 if (PyErr_Occurred()) SWIG_fail;
23120 }
23121 resultobj = SWIG_From_int(static_cast< int >(result));
23122 return resultobj;
23123 fail:
23124 return NULL;
23125 }
23126
23127
23128 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23129 PyObject *resultobj = 0;
23130 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23131 bool result;
23132 int val1 ;
23133 int ecode1 = 0 ;
23134 PyObject * obj0 = 0 ;
23135 char * kwnames[] = {
23136 (char *) "country", NULL
23137 };
23138
23139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23140 if (obj0) {
23141 ecode1 = SWIG_AsVal_int(obj0, &val1);
23142 if (!SWIG_IsOK(ecode1)) {
23143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23144 }
23145 arg1 = static_cast< wxDateTime::Country >(val1);
23146 }
23147 {
23148 PyThreadState* __tstate = wxPyBeginAllowThreads();
23149 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23150 wxPyEndAllowThreads(__tstate);
23151 if (PyErr_Occurred()) SWIG_fail;
23152 }
23153 {
23154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23155 }
23156 return resultobj;
23157 fail:
23158 return NULL;
23159 }
23160
23161
23162 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23163 PyObject *resultobj = 0;
23164 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23165 int result;
23166 int val1 ;
23167 int ecode1 = 0 ;
23168 PyObject * obj0 = 0 ;
23169 char * kwnames[] = {
23170 (char *) "cal", NULL
23171 };
23172
23173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23174 if (obj0) {
23175 ecode1 = SWIG_AsVal_int(obj0, &val1);
23176 if (!SWIG_IsOK(ecode1)) {
23177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23178 }
23179 arg1 = static_cast< wxDateTime::Calendar >(val1);
23180 }
23181 {
23182 PyThreadState* __tstate = wxPyBeginAllowThreads();
23183 result = (int)wxDateTime::GetCurrentYear(arg1);
23184 wxPyEndAllowThreads(__tstate);
23185 if (PyErr_Occurred()) SWIG_fail;
23186 }
23187 resultobj = SWIG_From_int(static_cast< int >(result));
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23195 PyObject *resultobj = 0;
23196 int arg1 ;
23197 int result;
23198 int val1 ;
23199 int ecode1 = 0 ;
23200 PyObject * obj0 = 0 ;
23201 char * kwnames[] = {
23202 (char *) "year", NULL
23203 };
23204
23205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23206 ecode1 = SWIG_AsVal_int(obj0, &val1);
23207 if (!SWIG_IsOK(ecode1)) {
23208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23209 }
23210 arg1 = static_cast< int >(val1);
23211 {
23212 PyThreadState* __tstate = wxPyBeginAllowThreads();
23213 result = (int)wxDateTime::ConvertYearToBC(arg1);
23214 wxPyEndAllowThreads(__tstate);
23215 if (PyErr_Occurred()) SWIG_fail;
23216 }
23217 resultobj = SWIG_From_int(static_cast< int >(result));
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23225 PyObject *resultobj = 0;
23226 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23227 wxDateTime::Month result;
23228 int val1 ;
23229 int ecode1 = 0 ;
23230 PyObject * obj0 = 0 ;
23231 char * kwnames[] = {
23232 (char *) "cal", NULL
23233 };
23234
23235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23236 if (obj0) {
23237 ecode1 = SWIG_AsVal_int(obj0, &val1);
23238 if (!SWIG_IsOK(ecode1)) {
23239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23240 }
23241 arg1 = static_cast< wxDateTime::Calendar >(val1);
23242 }
23243 {
23244 PyThreadState* __tstate = wxPyBeginAllowThreads();
23245 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 resultobj = SWIG_From_int(static_cast< int >(result));
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23257 PyObject *resultobj = 0;
23258 int arg1 = (int) wxDateTime::Inv_Year ;
23259 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23260 bool result;
23261 int val1 ;
23262 int ecode1 = 0 ;
23263 int val2 ;
23264 int ecode2 = 0 ;
23265 PyObject * obj0 = 0 ;
23266 PyObject * obj1 = 0 ;
23267 char * kwnames[] = {
23268 (char *) "year",(char *) "cal", NULL
23269 };
23270
23271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23272 if (obj0) {
23273 ecode1 = SWIG_AsVal_int(obj0, &val1);
23274 if (!SWIG_IsOK(ecode1)) {
23275 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23276 }
23277 arg1 = static_cast< int >(val1);
23278 }
23279 if (obj1) {
23280 ecode2 = SWIG_AsVal_int(obj1, &val2);
23281 if (!SWIG_IsOK(ecode2)) {
23282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23283 }
23284 arg2 = static_cast< wxDateTime::Calendar >(val2);
23285 }
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 {
23293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23294 }
23295 return resultobj;
23296 fail:
23297 return NULL;
23298 }
23299
23300
23301 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23302 PyObject *resultobj = 0;
23303 int arg1 = (int) wxDateTime::Inv_Year ;
23304 int result;
23305 int val1 ;
23306 int ecode1 = 0 ;
23307 PyObject * obj0 = 0 ;
23308 char * kwnames[] = {
23309 (char *) "year", NULL
23310 };
23311
23312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23313 if (obj0) {
23314 ecode1 = SWIG_AsVal_int(obj0, &val1);
23315 if (!SWIG_IsOK(ecode1)) {
23316 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23317 }
23318 arg1 = static_cast< int >(val1);
23319 }
23320 {
23321 PyThreadState* __tstate = wxPyBeginAllowThreads();
23322 result = (int)wxDateTime::GetCentury(arg1);
23323 wxPyEndAllowThreads(__tstate);
23324 if (PyErr_Occurred()) SWIG_fail;
23325 }
23326 resultobj = SWIG_From_int(static_cast< int >(result));
23327 return resultobj;
23328 fail:
23329 return NULL;
23330 }
23331
23332
23333 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23334 PyObject *resultobj = 0;
23335 int arg1 ;
23336 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23337 int result;
23338 int val1 ;
23339 int ecode1 = 0 ;
23340 int val2 ;
23341 int ecode2 = 0 ;
23342 PyObject * obj0 = 0 ;
23343 PyObject * obj1 = 0 ;
23344 char * kwnames[] = {
23345 (char *) "year",(char *) "cal", NULL
23346 };
23347
23348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23349 ecode1 = SWIG_AsVal_int(obj0, &val1);
23350 if (!SWIG_IsOK(ecode1)) {
23351 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23352 }
23353 arg1 = static_cast< int >(val1);
23354 if (obj1) {
23355 ecode2 = SWIG_AsVal_int(obj1, &val2);
23356 if (!SWIG_IsOK(ecode2)) {
23357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23358 }
23359 arg2 = static_cast< wxDateTime::Calendar >(val2);
23360 }
23361 {
23362 PyThreadState* __tstate = wxPyBeginAllowThreads();
23363 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23364 wxPyEndAllowThreads(__tstate);
23365 if (PyErr_Occurred()) SWIG_fail;
23366 }
23367 resultobj = SWIG_From_int(static_cast< int >(result));
23368 return resultobj;
23369 fail:
23370 return NULL;
23371 }
23372
23373
23374 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23375 PyObject *resultobj = 0;
23376 wxDateTime::Month arg1 ;
23377 int arg2 = (int) wxDateTime::Inv_Year ;
23378 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23379 int result;
23380 int val1 ;
23381 int ecode1 = 0 ;
23382 int val2 ;
23383 int ecode2 = 0 ;
23384 int val3 ;
23385 int ecode3 = 0 ;
23386 PyObject * obj0 = 0 ;
23387 PyObject * obj1 = 0 ;
23388 PyObject * obj2 = 0 ;
23389 char * kwnames[] = {
23390 (char *) "month",(char *) "year",(char *) "cal", NULL
23391 };
23392
23393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23394 ecode1 = SWIG_AsVal_int(obj0, &val1);
23395 if (!SWIG_IsOK(ecode1)) {
23396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23397 }
23398 arg1 = static_cast< wxDateTime::Month >(val1);
23399 if (obj1) {
23400 ecode2 = SWIG_AsVal_int(obj1, &val2);
23401 if (!SWIG_IsOK(ecode2)) {
23402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23403 }
23404 arg2 = static_cast< int >(val2);
23405 }
23406 if (obj2) {
23407 ecode3 = SWIG_AsVal_int(obj2, &val3);
23408 if (!SWIG_IsOK(ecode3)) {
23409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23410 }
23411 arg3 = static_cast< wxDateTime::Calendar >(val3);
23412 }
23413 {
23414 PyThreadState* __tstate = wxPyBeginAllowThreads();
23415 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23416 wxPyEndAllowThreads(__tstate);
23417 if (PyErr_Occurred()) SWIG_fail;
23418 }
23419 resultobj = SWIG_From_int(static_cast< int >(result));
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23427 PyObject *resultobj = 0;
23428 wxDateTime::Month arg1 ;
23429 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23430 wxString result;
23431 int val1 ;
23432 int ecode1 = 0 ;
23433 int val2 ;
23434 int ecode2 = 0 ;
23435 PyObject * obj0 = 0 ;
23436 PyObject * obj1 = 0 ;
23437 char * kwnames[] = {
23438 (char *) "month",(char *) "flags", NULL
23439 };
23440
23441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23442 ecode1 = SWIG_AsVal_int(obj0, &val1);
23443 if (!SWIG_IsOK(ecode1)) {
23444 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23445 }
23446 arg1 = static_cast< wxDateTime::Month >(val1);
23447 if (obj1) {
23448 ecode2 = SWIG_AsVal_int(obj1, &val2);
23449 if (!SWIG_IsOK(ecode2)) {
23450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23451 }
23452 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23453 }
23454 {
23455 PyThreadState* __tstate = wxPyBeginAllowThreads();
23456 result = wxDateTime::GetMonthName(arg1,arg2);
23457 wxPyEndAllowThreads(__tstate);
23458 if (PyErr_Occurred()) SWIG_fail;
23459 }
23460 {
23461 #if wxUSE_UNICODE
23462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23463 #else
23464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23465 #endif
23466 }
23467 return resultobj;
23468 fail:
23469 return NULL;
23470 }
23471
23472
23473 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23474 PyObject *resultobj = 0;
23475 wxDateTime::WeekDay arg1 ;
23476 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23477 wxString result;
23478 int val1 ;
23479 int ecode1 = 0 ;
23480 int val2 ;
23481 int ecode2 = 0 ;
23482 PyObject * obj0 = 0 ;
23483 PyObject * obj1 = 0 ;
23484 char * kwnames[] = {
23485 (char *) "weekday",(char *) "flags", NULL
23486 };
23487
23488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23489 ecode1 = SWIG_AsVal_int(obj0, &val1);
23490 if (!SWIG_IsOK(ecode1)) {
23491 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23492 }
23493 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23494 if (obj1) {
23495 ecode2 = SWIG_AsVal_int(obj1, &val2);
23496 if (!SWIG_IsOK(ecode2)) {
23497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23498 }
23499 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23500 }
23501 {
23502 PyThreadState* __tstate = wxPyBeginAllowThreads();
23503 result = wxDateTime::GetWeekDayName(arg1,arg2);
23504 wxPyEndAllowThreads(__tstate);
23505 if (PyErr_Occurred()) SWIG_fail;
23506 }
23507 {
23508 #if wxUSE_UNICODE
23509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23510 #else
23511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23512 #endif
23513 }
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23521 PyObject *resultobj = 0;
23522 PyObject *result = 0 ;
23523
23524 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 result = (PyObject *)wxDateTime_GetAmPmStrings();
23528 wxPyEndAllowThreads(__tstate);
23529 if (PyErr_Occurred()) SWIG_fail;
23530 }
23531 resultobj = result;
23532 return resultobj;
23533 fail:
23534 return NULL;
23535 }
23536
23537
23538 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23539 PyObject *resultobj = 0;
23540 int arg1 = (int) wxDateTime::Inv_Year ;
23541 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23542 bool result;
23543 int val1 ;
23544 int ecode1 = 0 ;
23545 int val2 ;
23546 int ecode2 = 0 ;
23547 PyObject * obj0 = 0 ;
23548 PyObject * obj1 = 0 ;
23549 char * kwnames[] = {
23550 (char *) "year",(char *) "country", NULL
23551 };
23552
23553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23554 if (obj0) {
23555 ecode1 = SWIG_AsVal_int(obj0, &val1);
23556 if (!SWIG_IsOK(ecode1)) {
23557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23558 }
23559 arg1 = static_cast< int >(val1);
23560 }
23561 if (obj1) {
23562 ecode2 = SWIG_AsVal_int(obj1, &val2);
23563 if (!SWIG_IsOK(ecode2)) {
23564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23565 }
23566 arg2 = static_cast< wxDateTime::Country >(val2);
23567 }
23568 {
23569 PyThreadState* __tstate = wxPyBeginAllowThreads();
23570 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23571 wxPyEndAllowThreads(__tstate);
23572 if (PyErr_Occurred()) SWIG_fail;
23573 }
23574 {
23575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23576 }
23577 return resultobj;
23578 fail:
23579 return NULL;
23580 }
23581
23582
23583 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23584 PyObject *resultobj = 0;
23585 int arg1 = (int) wxDateTime::Inv_Year ;
23586 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23587 wxDateTime result;
23588 int val1 ;
23589 int ecode1 = 0 ;
23590 int val2 ;
23591 int ecode2 = 0 ;
23592 PyObject * obj0 = 0 ;
23593 PyObject * obj1 = 0 ;
23594 char * kwnames[] = {
23595 (char *) "year",(char *) "country", NULL
23596 };
23597
23598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23599 if (obj0) {
23600 ecode1 = SWIG_AsVal_int(obj0, &val1);
23601 if (!SWIG_IsOK(ecode1)) {
23602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23603 }
23604 arg1 = static_cast< int >(val1);
23605 }
23606 if (obj1) {
23607 ecode2 = SWIG_AsVal_int(obj1, &val2);
23608 if (!SWIG_IsOK(ecode2)) {
23609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23610 }
23611 arg2 = static_cast< wxDateTime::Country >(val2);
23612 }
23613 {
23614 PyThreadState* __tstate = wxPyBeginAllowThreads();
23615 result = wxDateTime::GetBeginDST(arg1,arg2);
23616 wxPyEndAllowThreads(__tstate);
23617 if (PyErr_Occurred()) SWIG_fail;
23618 }
23619 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23620 return resultobj;
23621 fail:
23622 return NULL;
23623 }
23624
23625
23626 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23627 PyObject *resultobj = 0;
23628 int arg1 = (int) wxDateTime::Inv_Year ;
23629 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23630 wxDateTime result;
23631 int val1 ;
23632 int ecode1 = 0 ;
23633 int val2 ;
23634 int ecode2 = 0 ;
23635 PyObject * obj0 = 0 ;
23636 PyObject * obj1 = 0 ;
23637 char * kwnames[] = {
23638 (char *) "year",(char *) "country", NULL
23639 };
23640
23641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23642 if (obj0) {
23643 ecode1 = SWIG_AsVal_int(obj0, &val1);
23644 if (!SWIG_IsOK(ecode1)) {
23645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23646 }
23647 arg1 = static_cast< int >(val1);
23648 }
23649 if (obj1) {
23650 ecode2 = SWIG_AsVal_int(obj1, &val2);
23651 if (!SWIG_IsOK(ecode2)) {
23652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23653 }
23654 arg2 = static_cast< wxDateTime::Country >(val2);
23655 }
23656 {
23657 PyThreadState* __tstate = wxPyBeginAllowThreads();
23658 result = wxDateTime::GetEndDST(arg1,arg2);
23659 wxPyEndAllowThreads(__tstate);
23660 if (PyErr_Occurred()) SWIG_fail;
23661 }
23662 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23663 return resultobj;
23664 fail:
23665 return NULL;
23666 }
23667
23668
23669 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23670 PyObject *resultobj = 0;
23671 wxDateTime result;
23672
23673 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23674 {
23675 PyThreadState* __tstate = wxPyBeginAllowThreads();
23676 result = wxDateTime::Now();
23677 wxPyEndAllowThreads(__tstate);
23678 if (PyErr_Occurred()) SWIG_fail;
23679 }
23680 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23681 return resultobj;
23682 fail:
23683 return NULL;
23684 }
23685
23686
23687 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23688 PyObject *resultobj = 0;
23689 wxDateTime result;
23690
23691 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = wxDateTime::UNow();
23695 wxPyEndAllowThreads(__tstate);
23696 if (PyErr_Occurred()) SWIG_fail;
23697 }
23698 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23699 return resultobj;
23700 fail:
23701 return NULL;
23702 }
23703
23704
23705 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23706 PyObject *resultobj = 0;
23707 wxDateTime result;
23708
23709 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23710 {
23711 PyThreadState* __tstate = wxPyBeginAllowThreads();
23712 result = wxDateTime::Today();
23713 wxPyEndAllowThreads(__tstate);
23714 if (PyErr_Occurred()) SWIG_fail;
23715 }
23716 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23717 return resultobj;
23718 fail:
23719 return NULL;
23720 }
23721
23722
23723 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23724 PyObject *resultobj = 0;
23725 wxDateTime *result = 0 ;
23726
23727 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23728 {
23729 PyThreadState* __tstate = wxPyBeginAllowThreads();
23730 result = (wxDateTime *)new wxDateTime();
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23735 return resultobj;
23736 fail:
23737 return NULL;
23738 }
23739
23740
23741 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23742 PyObject *resultobj = 0;
23743 time_t arg1 ;
23744 wxDateTime *result = 0 ;
23745 unsigned int val1 ;
23746 int ecode1 = 0 ;
23747 PyObject * obj0 = 0 ;
23748 char * kwnames[] = {
23749 (char *) "timet", NULL
23750 };
23751
23752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23753 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23754 if (!SWIG_IsOK(ecode1)) {
23755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23756 }
23757 arg1 = static_cast< time_t >(val1);
23758 {
23759 PyThreadState* __tstate = wxPyBeginAllowThreads();
23760 result = (wxDateTime *)new wxDateTime(arg1);
23761 wxPyEndAllowThreads(__tstate);
23762 if (PyErr_Occurred()) SWIG_fail;
23763 }
23764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23765 return resultobj;
23766 fail:
23767 return NULL;
23768 }
23769
23770
23771 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23772 PyObject *resultobj = 0;
23773 double arg1 ;
23774 wxDateTime *result = 0 ;
23775 double val1 ;
23776 int ecode1 = 0 ;
23777 PyObject * obj0 = 0 ;
23778 char * kwnames[] = {
23779 (char *) "jdn", NULL
23780 };
23781
23782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23783 ecode1 = SWIG_AsVal_double(obj0, &val1);
23784 if (!SWIG_IsOK(ecode1)) {
23785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23786 }
23787 arg1 = static_cast< double >(val1);
23788 {
23789 PyThreadState* __tstate = wxPyBeginAllowThreads();
23790 result = (wxDateTime *)new wxDateTime(arg1);
23791 wxPyEndAllowThreads(__tstate);
23792 if (PyErr_Occurred()) SWIG_fail;
23793 }
23794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23795 return resultobj;
23796 fail:
23797 return NULL;
23798 }
23799
23800
23801 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23802 PyObject *resultobj = 0;
23803 int arg1 ;
23804 int arg2 = (int) 0 ;
23805 int arg3 = (int) 0 ;
23806 int arg4 = (int) 0 ;
23807 wxDateTime *result = 0 ;
23808 int val1 ;
23809 int ecode1 = 0 ;
23810 int val2 ;
23811 int ecode2 = 0 ;
23812 int val3 ;
23813 int ecode3 = 0 ;
23814 int val4 ;
23815 int ecode4 = 0 ;
23816 PyObject * obj0 = 0 ;
23817 PyObject * obj1 = 0 ;
23818 PyObject * obj2 = 0 ;
23819 PyObject * obj3 = 0 ;
23820 char * kwnames[] = {
23821 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23822 };
23823
23824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23825 ecode1 = SWIG_AsVal_int(obj0, &val1);
23826 if (!SWIG_IsOK(ecode1)) {
23827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23828 }
23829 arg1 = static_cast< int >(val1);
23830 if (obj1) {
23831 ecode2 = SWIG_AsVal_int(obj1, &val2);
23832 if (!SWIG_IsOK(ecode2)) {
23833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23834 }
23835 arg2 = static_cast< int >(val2);
23836 }
23837 if (obj2) {
23838 ecode3 = SWIG_AsVal_int(obj2, &val3);
23839 if (!SWIG_IsOK(ecode3)) {
23840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23841 }
23842 arg3 = static_cast< int >(val3);
23843 }
23844 if (obj3) {
23845 ecode4 = SWIG_AsVal_int(obj3, &val4);
23846 if (!SWIG_IsOK(ecode4)) {
23847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23848 }
23849 arg4 = static_cast< int >(val4);
23850 }
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23858 return resultobj;
23859 fail:
23860 return NULL;
23861 }
23862
23863
23864 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23865 PyObject *resultobj = 0;
23866 int arg1 ;
23867 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23868 int arg3 = (int) wxDateTime::Inv_Year ;
23869 int arg4 = (int) 0 ;
23870 int arg5 = (int) 0 ;
23871 int arg6 = (int) 0 ;
23872 int arg7 = (int) 0 ;
23873 wxDateTime *result = 0 ;
23874 int val1 ;
23875 int ecode1 = 0 ;
23876 int val2 ;
23877 int ecode2 = 0 ;
23878 int val3 ;
23879 int ecode3 = 0 ;
23880 int val4 ;
23881 int ecode4 = 0 ;
23882 int val5 ;
23883 int ecode5 = 0 ;
23884 int val6 ;
23885 int ecode6 = 0 ;
23886 int val7 ;
23887 int ecode7 = 0 ;
23888 PyObject * obj0 = 0 ;
23889 PyObject * obj1 = 0 ;
23890 PyObject * obj2 = 0 ;
23891 PyObject * obj3 = 0 ;
23892 PyObject * obj4 = 0 ;
23893 PyObject * obj5 = 0 ;
23894 PyObject * obj6 = 0 ;
23895 char * kwnames[] = {
23896 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23897 };
23898
23899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23900 ecode1 = SWIG_AsVal_int(obj0, &val1);
23901 if (!SWIG_IsOK(ecode1)) {
23902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23903 }
23904 arg1 = static_cast< int >(val1);
23905 if (obj1) {
23906 ecode2 = SWIG_AsVal_int(obj1, &val2);
23907 if (!SWIG_IsOK(ecode2)) {
23908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23909 }
23910 arg2 = static_cast< wxDateTime::Month >(val2);
23911 }
23912 if (obj2) {
23913 ecode3 = SWIG_AsVal_int(obj2, &val3);
23914 if (!SWIG_IsOK(ecode3)) {
23915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
23916 }
23917 arg3 = static_cast< int >(val3);
23918 }
23919 if (obj3) {
23920 ecode4 = SWIG_AsVal_int(obj3, &val4);
23921 if (!SWIG_IsOK(ecode4)) {
23922 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
23923 }
23924 arg4 = static_cast< int >(val4);
23925 }
23926 if (obj4) {
23927 ecode5 = SWIG_AsVal_int(obj4, &val5);
23928 if (!SWIG_IsOK(ecode5)) {
23929 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
23930 }
23931 arg5 = static_cast< int >(val5);
23932 }
23933 if (obj5) {
23934 ecode6 = SWIG_AsVal_int(obj5, &val6);
23935 if (!SWIG_IsOK(ecode6)) {
23936 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
23937 }
23938 arg6 = static_cast< int >(val6);
23939 }
23940 if (obj6) {
23941 ecode7 = SWIG_AsVal_int(obj6, &val7);
23942 if (!SWIG_IsOK(ecode7)) {
23943 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
23944 }
23945 arg7 = static_cast< int >(val7);
23946 }
23947 {
23948 PyThreadState* __tstate = wxPyBeginAllowThreads();
23949 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23950 wxPyEndAllowThreads(__tstate);
23951 if (PyErr_Occurred()) SWIG_fail;
23952 }
23953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23954 return resultobj;
23955 fail:
23956 return NULL;
23957 }
23958
23959
23960 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23961 PyObject *resultobj = 0;
23962 wxDateTime *arg1 = 0 ;
23963 wxDateTime *result = 0 ;
23964 void *argp1 = 0 ;
23965 int res1 = 0 ;
23966 PyObject * obj0 = 0 ;
23967 char * kwnames[] = {
23968 (char *) "date", NULL
23969 };
23970
23971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
23972 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
23973 if (!SWIG_IsOK(res1)) {
23974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23975 }
23976 if (!argp1) {
23977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
23978 }
23979 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23980 {
23981 PyThreadState* __tstate = wxPyBeginAllowThreads();
23982 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
23983 wxPyEndAllowThreads(__tstate);
23984 if (PyErr_Occurred()) SWIG_fail;
23985 }
23986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23987 return resultobj;
23988 fail:
23989 return NULL;
23990 }
23991
23992
23993 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23994 PyObject *resultobj = 0;
23995 wxDateTime *arg1 = (wxDateTime *) 0 ;
23996 void *argp1 = 0 ;
23997 int res1 = 0 ;
23998 PyObject *swig_obj[1] ;
23999
24000 if (!args) SWIG_fail;
24001 swig_obj[0] = args;
24002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24003 if (!SWIG_IsOK(res1)) {
24004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24005 }
24006 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24007 {
24008 PyThreadState* __tstate = wxPyBeginAllowThreads();
24009 delete arg1;
24010
24011 wxPyEndAllowThreads(__tstate);
24012 if (PyErr_Occurred()) SWIG_fail;
24013 }
24014 resultobj = SWIG_Py_Void();
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxDateTime *arg1 = (wxDateTime *) 0 ;
24024 wxDateTime *result = 0 ;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 PyObject *swig_obj[1] ;
24028
24029 if (!args) SWIG_fail;
24030 swig_obj[0] = args;
24031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24034 }
24035 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24036 {
24037 PyThreadState* __tstate = wxPyBeginAllowThreads();
24038 {
24039 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24040 result = (wxDateTime *) &_result_ref;
24041 }
24042 wxPyEndAllowThreads(__tstate);
24043 if (PyErr_Occurred()) SWIG_fail;
24044 }
24045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24046 return resultobj;
24047 fail:
24048 return NULL;
24049 }
24050
24051
24052 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24053 PyObject *resultobj = 0;
24054 wxDateTime *arg1 = (wxDateTime *) 0 ;
24055 time_t arg2 ;
24056 wxDateTime *result = 0 ;
24057 void *argp1 = 0 ;
24058 int res1 = 0 ;
24059 unsigned int val2 ;
24060 int ecode2 = 0 ;
24061 PyObject * obj0 = 0 ;
24062 PyObject * obj1 = 0 ;
24063 char * kwnames[] = {
24064 (char *) "self",(char *) "timet", NULL
24065 };
24066
24067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24069 if (!SWIG_IsOK(res1)) {
24070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24071 }
24072 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24073 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24074 if (!SWIG_IsOK(ecode2)) {
24075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24076 }
24077 arg2 = static_cast< time_t >(val2);
24078 {
24079 PyThreadState* __tstate = wxPyBeginAllowThreads();
24080 {
24081 wxDateTime &_result_ref = (arg1)->Set(arg2);
24082 result = (wxDateTime *) &_result_ref;
24083 }
24084 wxPyEndAllowThreads(__tstate);
24085 if (PyErr_Occurred()) SWIG_fail;
24086 }
24087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24088 return resultobj;
24089 fail:
24090 return NULL;
24091 }
24092
24093
24094 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24095 PyObject *resultobj = 0;
24096 wxDateTime *arg1 = (wxDateTime *) 0 ;
24097 double arg2 ;
24098 wxDateTime *result = 0 ;
24099 void *argp1 = 0 ;
24100 int res1 = 0 ;
24101 double val2 ;
24102 int ecode2 = 0 ;
24103 PyObject * obj0 = 0 ;
24104 PyObject * obj1 = 0 ;
24105 char * kwnames[] = {
24106 (char *) "self",(char *) "jdn", NULL
24107 };
24108
24109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24111 if (!SWIG_IsOK(res1)) {
24112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24113 }
24114 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24115 ecode2 = SWIG_AsVal_double(obj1, &val2);
24116 if (!SWIG_IsOK(ecode2)) {
24117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24118 }
24119 arg2 = static_cast< double >(val2);
24120 {
24121 PyThreadState* __tstate = wxPyBeginAllowThreads();
24122 {
24123 wxDateTime &_result_ref = (arg1)->Set(arg2);
24124 result = (wxDateTime *) &_result_ref;
24125 }
24126 wxPyEndAllowThreads(__tstate);
24127 if (PyErr_Occurred()) SWIG_fail;
24128 }
24129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24130 return resultobj;
24131 fail:
24132 return NULL;
24133 }
24134
24135
24136 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24137 PyObject *resultobj = 0;
24138 wxDateTime *arg1 = (wxDateTime *) 0 ;
24139 int arg2 ;
24140 int arg3 = (int) 0 ;
24141 int arg4 = (int) 0 ;
24142 int arg5 = (int) 0 ;
24143 wxDateTime *result = 0 ;
24144 void *argp1 = 0 ;
24145 int res1 = 0 ;
24146 int val2 ;
24147 int ecode2 = 0 ;
24148 int val3 ;
24149 int ecode3 = 0 ;
24150 int val4 ;
24151 int ecode4 = 0 ;
24152 int val5 ;
24153 int ecode5 = 0 ;
24154 PyObject * obj0 = 0 ;
24155 PyObject * obj1 = 0 ;
24156 PyObject * obj2 = 0 ;
24157 PyObject * obj3 = 0 ;
24158 PyObject * obj4 = 0 ;
24159 char * kwnames[] = {
24160 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24161 };
24162
24163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24165 if (!SWIG_IsOK(res1)) {
24166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24167 }
24168 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24169 ecode2 = SWIG_AsVal_int(obj1, &val2);
24170 if (!SWIG_IsOK(ecode2)) {
24171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24172 }
24173 arg2 = static_cast< int >(val2);
24174 if (obj2) {
24175 ecode3 = SWIG_AsVal_int(obj2, &val3);
24176 if (!SWIG_IsOK(ecode3)) {
24177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24178 }
24179 arg3 = static_cast< int >(val3);
24180 }
24181 if (obj3) {
24182 ecode4 = SWIG_AsVal_int(obj3, &val4);
24183 if (!SWIG_IsOK(ecode4)) {
24184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24185 }
24186 arg4 = static_cast< int >(val4);
24187 }
24188 if (obj4) {
24189 ecode5 = SWIG_AsVal_int(obj4, &val5);
24190 if (!SWIG_IsOK(ecode5)) {
24191 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24192 }
24193 arg5 = static_cast< int >(val5);
24194 }
24195 {
24196 PyThreadState* __tstate = wxPyBeginAllowThreads();
24197 {
24198 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24199 result = (wxDateTime *) &_result_ref;
24200 }
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24205 return resultobj;
24206 fail:
24207 return NULL;
24208 }
24209
24210
24211 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj = 0;
24213 wxDateTime *arg1 = (wxDateTime *) 0 ;
24214 int arg2 ;
24215 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24216 int arg4 = (int) wxDateTime::Inv_Year ;
24217 int arg5 = (int) 0 ;
24218 int arg6 = (int) 0 ;
24219 int arg7 = (int) 0 ;
24220 int arg8 = (int) 0 ;
24221 wxDateTime *result = 0 ;
24222 void *argp1 = 0 ;
24223 int res1 = 0 ;
24224 int val2 ;
24225 int ecode2 = 0 ;
24226 int val3 ;
24227 int ecode3 = 0 ;
24228 int val4 ;
24229 int ecode4 = 0 ;
24230 int val5 ;
24231 int ecode5 = 0 ;
24232 int val6 ;
24233 int ecode6 = 0 ;
24234 int val7 ;
24235 int ecode7 = 0 ;
24236 int val8 ;
24237 int ecode8 = 0 ;
24238 PyObject * obj0 = 0 ;
24239 PyObject * obj1 = 0 ;
24240 PyObject * obj2 = 0 ;
24241 PyObject * obj3 = 0 ;
24242 PyObject * obj4 = 0 ;
24243 PyObject * obj5 = 0 ;
24244 PyObject * obj6 = 0 ;
24245 PyObject * obj7 = 0 ;
24246 char * kwnames[] = {
24247 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24248 };
24249
24250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24252 if (!SWIG_IsOK(res1)) {
24253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24254 }
24255 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24256 ecode2 = SWIG_AsVal_int(obj1, &val2);
24257 if (!SWIG_IsOK(ecode2)) {
24258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24259 }
24260 arg2 = static_cast< int >(val2);
24261 if (obj2) {
24262 ecode3 = SWIG_AsVal_int(obj2, &val3);
24263 if (!SWIG_IsOK(ecode3)) {
24264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24265 }
24266 arg3 = static_cast< wxDateTime::Month >(val3);
24267 }
24268 if (obj3) {
24269 ecode4 = SWIG_AsVal_int(obj3, &val4);
24270 if (!SWIG_IsOK(ecode4)) {
24271 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24272 }
24273 arg4 = static_cast< int >(val4);
24274 }
24275 if (obj4) {
24276 ecode5 = SWIG_AsVal_int(obj4, &val5);
24277 if (!SWIG_IsOK(ecode5)) {
24278 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24279 }
24280 arg5 = static_cast< int >(val5);
24281 }
24282 if (obj5) {
24283 ecode6 = SWIG_AsVal_int(obj5, &val6);
24284 if (!SWIG_IsOK(ecode6)) {
24285 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24286 }
24287 arg6 = static_cast< int >(val6);
24288 }
24289 if (obj6) {
24290 ecode7 = SWIG_AsVal_int(obj6, &val7);
24291 if (!SWIG_IsOK(ecode7)) {
24292 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24293 }
24294 arg7 = static_cast< int >(val7);
24295 }
24296 if (obj7) {
24297 ecode8 = SWIG_AsVal_int(obj7, &val8);
24298 if (!SWIG_IsOK(ecode8)) {
24299 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24300 }
24301 arg8 = static_cast< int >(val8);
24302 }
24303 {
24304 PyThreadState* __tstate = wxPyBeginAllowThreads();
24305 {
24306 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24307 result = (wxDateTime *) &_result_ref;
24308 }
24309 wxPyEndAllowThreads(__tstate);
24310 if (PyErr_Occurred()) SWIG_fail;
24311 }
24312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24313 return resultobj;
24314 fail:
24315 return NULL;
24316 }
24317
24318
24319 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24320 PyObject *resultobj = 0;
24321 wxDateTime *arg1 = (wxDateTime *) 0 ;
24322 wxDateTime *result = 0 ;
24323 void *argp1 = 0 ;
24324 int res1 = 0 ;
24325 PyObject *swig_obj[1] ;
24326
24327 if (!args) SWIG_fail;
24328 swig_obj[0] = args;
24329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24330 if (!SWIG_IsOK(res1)) {
24331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24332 }
24333 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24334 {
24335 PyThreadState* __tstate = wxPyBeginAllowThreads();
24336 {
24337 wxDateTime &_result_ref = (arg1)->ResetTime();
24338 result = (wxDateTime *) &_result_ref;
24339 }
24340 wxPyEndAllowThreads(__tstate);
24341 if (PyErr_Occurred()) SWIG_fail;
24342 }
24343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj = 0;
24352 wxDateTime *arg1 = (wxDateTime *) 0 ;
24353 int arg2 ;
24354 wxDateTime *result = 0 ;
24355 void *argp1 = 0 ;
24356 int res1 = 0 ;
24357 int val2 ;
24358 int ecode2 = 0 ;
24359 PyObject * obj0 = 0 ;
24360 PyObject * obj1 = 0 ;
24361 char * kwnames[] = {
24362 (char *) "self",(char *) "year", NULL
24363 };
24364
24365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24367 if (!SWIG_IsOK(res1)) {
24368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24369 }
24370 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24371 ecode2 = SWIG_AsVal_int(obj1, &val2);
24372 if (!SWIG_IsOK(ecode2)) {
24373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24374 }
24375 arg2 = static_cast< int >(val2);
24376 {
24377 PyThreadState* __tstate = wxPyBeginAllowThreads();
24378 {
24379 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24380 result = (wxDateTime *) &_result_ref;
24381 }
24382 wxPyEndAllowThreads(__tstate);
24383 if (PyErr_Occurred()) SWIG_fail;
24384 }
24385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24386 return resultobj;
24387 fail:
24388 return NULL;
24389 }
24390
24391
24392 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24393 PyObject *resultobj = 0;
24394 wxDateTime *arg1 = (wxDateTime *) 0 ;
24395 wxDateTime::Month arg2 ;
24396 wxDateTime *result = 0 ;
24397 void *argp1 = 0 ;
24398 int res1 = 0 ;
24399 int val2 ;
24400 int ecode2 = 0 ;
24401 PyObject * obj0 = 0 ;
24402 PyObject * obj1 = 0 ;
24403 char * kwnames[] = {
24404 (char *) "self",(char *) "month", NULL
24405 };
24406
24407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24409 if (!SWIG_IsOK(res1)) {
24410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24411 }
24412 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24413 ecode2 = SWIG_AsVal_int(obj1, &val2);
24414 if (!SWIG_IsOK(ecode2)) {
24415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24416 }
24417 arg2 = static_cast< wxDateTime::Month >(val2);
24418 {
24419 PyThreadState* __tstate = wxPyBeginAllowThreads();
24420 {
24421 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24422 result = (wxDateTime *) &_result_ref;
24423 }
24424 wxPyEndAllowThreads(__tstate);
24425 if (PyErr_Occurred()) SWIG_fail;
24426 }
24427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24428 return resultobj;
24429 fail:
24430 return NULL;
24431 }
24432
24433
24434 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24435 PyObject *resultobj = 0;
24436 wxDateTime *arg1 = (wxDateTime *) 0 ;
24437 int arg2 ;
24438 wxDateTime *result = 0 ;
24439 void *argp1 = 0 ;
24440 int res1 = 0 ;
24441 int val2 ;
24442 int ecode2 = 0 ;
24443 PyObject * obj0 = 0 ;
24444 PyObject * obj1 = 0 ;
24445 char * kwnames[] = {
24446 (char *) "self",(char *) "day", NULL
24447 };
24448
24449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24451 if (!SWIG_IsOK(res1)) {
24452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24453 }
24454 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24455 ecode2 = SWIG_AsVal_int(obj1, &val2);
24456 if (!SWIG_IsOK(ecode2)) {
24457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24458 }
24459 arg2 = static_cast< int >(val2);
24460 {
24461 PyThreadState* __tstate = wxPyBeginAllowThreads();
24462 {
24463 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24464 result = (wxDateTime *) &_result_ref;
24465 }
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj = 0;
24478 wxDateTime *arg1 = (wxDateTime *) 0 ;
24479 int arg2 ;
24480 wxDateTime *result = 0 ;
24481 void *argp1 = 0 ;
24482 int res1 = 0 ;
24483 int val2 ;
24484 int ecode2 = 0 ;
24485 PyObject * obj0 = 0 ;
24486 PyObject * obj1 = 0 ;
24487 char * kwnames[] = {
24488 (char *) "self",(char *) "hour", NULL
24489 };
24490
24491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24493 if (!SWIG_IsOK(res1)) {
24494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24495 }
24496 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24497 ecode2 = SWIG_AsVal_int(obj1, &val2);
24498 if (!SWIG_IsOK(ecode2)) {
24499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24500 }
24501 arg2 = static_cast< int >(val2);
24502 {
24503 PyThreadState* __tstate = wxPyBeginAllowThreads();
24504 {
24505 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24506 result = (wxDateTime *) &_result_ref;
24507 }
24508 wxPyEndAllowThreads(__tstate);
24509 if (PyErr_Occurred()) SWIG_fail;
24510 }
24511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24512 return resultobj;
24513 fail:
24514 return NULL;
24515 }
24516
24517
24518 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24519 PyObject *resultobj = 0;
24520 wxDateTime *arg1 = (wxDateTime *) 0 ;
24521 int arg2 ;
24522 wxDateTime *result = 0 ;
24523 void *argp1 = 0 ;
24524 int res1 = 0 ;
24525 int val2 ;
24526 int ecode2 = 0 ;
24527 PyObject * obj0 = 0 ;
24528 PyObject * obj1 = 0 ;
24529 char * kwnames[] = {
24530 (char *) "self",(char *) "minute", NULL
24531 };
24532
24533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24537 }
24538 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24539 ecode2 = SWIG_AsVal_int(obj1, &val2);
24540 if (!SWIG_IsOK(ecode2)) {
24541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24542 }
24543 arg2 = static_cast< int >(val2);
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 {
24547 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24548 result = (wxDateTime *) &_result_ref;
24549 }
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24554 return resultobj;
24555 fail:
24556 return NULL;
24557 }
24558
24559
24560 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24561 PyObject *resultobj = 0;
24562 wxDateTime *arg1 = (wxDateTime *) 0 ;
24563 int arg2 ;
24564 wxDateTime *result = 0 ;
24565 void *argp1 = 0 ;
24566 int res1 = 0 ;
24567 int val2 ;
24568 int ecode2 = 0 ;
24569 PyObject * obj0 = 0 ;
24570 PyObject * obj1 = 0 ;
24571 char * kwnames[] = {
24572 (char *) "self",(char *) "second", NULL
24573 };
24574
24575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24577 if (!SWIG_IsOK(res1)) {
24578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24579 }
24580 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24581 ecode2 = SWIG_AsVal_int(obj1, &val2);
24582 if (!SWIG_IsOK(ecode2)) {
24583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24584 }
24585 arg2 = static_cast< int >(val2);
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 {
24589 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24590 result = (wxDateTime *) &_result_ref;
24591 }
24592 wxPyEndAllowThreads(__tstate);
24593 if (PyErr_Occurred()) SWIG_fail;
24594 }
24595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24596 return resultobj;
24597 fail:
24598 return NULL;
24599 }
24600
24601
24602 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24603 PyObject *resultobj = 0;
24604 wxDateTime *arg1 = (wxDateTime *) 0 ;
24605 int arg2 ;
24606 wxDateTime *result = 0 ;
24607 void *argp1 = 0 ;
24608 int res1 = 0 ;
24609 int val2 ;
24610 int ecode2 = 0 ;
24611 PyObject * obj0 = 0 ;
24612 PyObject * obj1 = 0 ;
24613 char * kwnames[] = {
24614 (char *) "self",(char *) "millisecond", NULL
24615 };
24616
24617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24619 if (!SWIG_IsOK(res1)) {
24620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24621 }
24622 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24623 ecode2 = SWIG_AsVal_int(obj1, &val2);
24624 if (!SWIG_IsOK(ecode2)) {
24625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24626 }
24627 arg2 = static_cast< int >(val2);
24628 {
24629 PyThreadState* __tstate = wxPyBeginAllowThreads();
24630 {
24631 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24632 result = (wxDateTime *) &_result_ref;
24633 }
24634 wxPyEndAllowThreads(__tstate);
24635 if (PyErr_Occurred()) SWIG_fail;
24636 }
24637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24638 return resultobj;
24639 fail:
24640 return NULL;
24641 }
24642
24643
24644 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24645 PyObject *resultobj = 0;
24646 wxDateTime *arg1 = (wxDateTime *) 0 ;
24647 wxDateTime::WeekDay arg2 ;
24648 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24649 wxDateTime *result = 0 ;
24650 void *argp1 = 0 ;
24651 int res1 = 0 ;
24652 int val2 ;
24653 int ecode2 = 0 ;
24654 int val3 ;
24655 int ecode3 = 0 ;
24656 PyObject * obj0 = 0 ;
24657 PyObject * obj1 = 0 ;
24658 PyObject * obj2 = 0 ;
24659 char * kwnames[] = {
24660 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24661 };
24662
24663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24665 if (!SWIG_IsOK(res1)) {
24666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24667 }
24668 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24669 ecode2 = SWIG_AsVal_int(obj1, &val2);
24670 if (!SWIG_IsOK(ecode2)) {
24671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24672 }
24673 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24674 if (obj2) {
24675 ecode3 = SWIG_AsVal_int(obj2, &val3);
24676 if (!SWIG_IsOK(ecode3)) {
24677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24678 }
24679 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24680 }
24681 {
24682 PyThreadState* __tstate = wxPyBeginAllowThreads();
24683 {
24684 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24685 result = (wxDateTime *) &_result_ref;
24686 }
24687 wxPyEndAllowThreads(__tstate);
24688 if (PyErr_Occurred()) SWIG_fail;
24689 }
24690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24691 return resultobj;
24692 fail:
24693 return NULL;
24694 }
24695
24696
24697 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24698 PyObject *resultobj = 0;
24699 wxDateTime *arg1 = (wxDateTime *) 0 ;
24700 wxDateTime::WeekDay arg2 ;
24701 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24702 wxDateTime result;
24703 void *argp1 = 0 ;
24704 int res1 = 0 ;
24705 int val2 ;
24706 int ecode2 = 0 ;
24707 int val3 ;
24708 int ecode3 = 0 ;
24709 PyObject * obj0 = 0 ;
24710 PyObject * obj1 = 0 ;
24711 PyObject * obj2 = 0 ;
24712 char * kwnames[] = {
24713 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24714 };
24715
24716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24718 if (!SWIG_IsOK(res1)) {
24719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24720 }
24721 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24722 ecode2 = SWIG_AsVal_int(obj1, &val2);
24723 if (!SWIG_IsOK(ecode2)) {
24724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24725 }
24726 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24727 if (obj2) {
24728 ecode3 = SWIG_AsVal_int(obj2, &val3);
24729 if (!SWIG_IsOK(ecode3)) {
24730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24731 }
24732 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24733 }
24734 {
24735 PyThreadState* __tstate = wxPyBeginAllowThreads();
24736 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24737 wxPyEndAllowThreads(__tstate);
24738 if (PyErr_Occurred()) SWIG_fail;
24739 }
24740 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24748 PyObject *resultobj = 0;
24749 wxDateTime *arg1 = (wxDateTime *) 0 ;
24750 wxDateTime::WeekDay arg2 ;
24751 wxDateTime *result = 0 ;
24752 void *argp1 = 0 ;
24753 int res1 = 0 ;
24754 int val2 ;
24755 int ecode2 = 0 ;
24756 PyObject * obj0 = 0 ;
24757 PyObject * obj1 = 0 ;
24758 char * kwnames[] = {
24759 (char *) "self",(char *) "weekday", NULL
24760 };
24761
24762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24764 if (!SWIG_IsOK(res1)) {
24765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24766 }
24767 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24768 ecode2 = SWIG_AsVal_int(obj1, &val2);
24769 if (!SWIG_IsOK(ecode2)) {
24770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24771 }
24772 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24773 {
24774 PyThreadState* __tstate = wxPyBeginAllowThreads();
24775 {
24776 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24777 result = (wxDateTime *) &_result_ref;
24778 }
24779 wxPyEndAllowThreads(__tstate);
24780 if (PyErr_Occurred()) SWIG_fail;
24781 }
24782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24783 return resultobj;
24784 fail:
24785 return NULL;
24786 }
24787
24788
24789 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24790 PyObject *resultobj = 0;
24791 wxDateTime *arg1 = (wxDateTime *) 0 ;
24792 wxDateTime::WeekDay arg2 ;
24793 wxDateTime result;
24794 void *argp1 = 0 ;
24795 int res1 = 0 ;
24796 int val2 ;
24797 int ecode2 = 0 ;
24798 PyObject * obj0 = 0 ;
24799 PyObject * obj1 = 0 ;
24800 char * kwnames[] = {
24801 (char *) "self",(char *) "weekday", NULL
24802 };
24803
24804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24806 if (!SWIG_IsOK(res1)) {
24807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24808 }
24809 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24810 ecode2 = SWIG_AsVal_int(obj1, &val2);
24811 if (!SWIG_IsOK(ecode2)) {
24812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24813 }
24814 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24815 {
24816 PyThreadState* __tstate = wxPyBeginAllowThreads();
24817 result = (arg1)->GetNextWeekDay(arg2);
24818 wxPyEndAllowThreads(__tstate);
24819 if (PyErr_Occurred()) SWIG_fail;
24820 }
24821 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24822 return resultobj;
24823 fail:
24824 return NULL;
24825 }
24826
24827
24828 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24829 PyObject *resultobj = 0;
24830 wxDateTime *arg1 = (wxDateTime *) 0 ;
24831 wxDateTime::WeekDay arg2 ;
24832 wxDateTime *result = 0 ;
24833 void *argp1 = 0 ;
24834 int res1 = 0 ;
24835 int val2 ;
24836 int ecode2 = 0 ;
24837 PyObject * obj0 = 0 ;
24838 PyObject * obj1 = 0 ;
24839 char * kwnames[] = {
24840 (char *) "self",(char *) "weekday", NULL
24841 };
24842
24843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) 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_SetToPrevWeekDay" "', 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_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24852 }
24853 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24854 {
24855 PyThreadState* __tstate = wxPyBeginAllowThreads();
24856 {
24857 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24858 result = (wxDateTime *) &_result_ref;
24859 }
24860 wxPyEndAllowThreads(__tstate);
24861 if (PyErr_Occurred()) SWIG_fail;
24862 }
24863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24864 return resultobj;
24865 fail:
24866 return NULL;
24867 }
24868
24869
24870 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24871 PyObject *resultobj = 0;
24872 wxDateTime *arg1 = (wxDateTime *) 0 ;
24873 wxDateTime::WeekDay arg2 ;
24874 wxDateTime result;
24875 void *argp1 = 0 ;
24876 int res1 = 0 ;
24877 int val2 ;
24878 int ecode2 = 0 ;
24879 PyObject * obj0 = 0 ;
24880 PyObject * obj1 = 0 ;
24881 char * kwnames[] = {
24882 (char *) "self",(char *) "weekday", NULL
24883 };
24884
24885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24887 if (!SWIG_IsOK(res1)) {
24888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24889 }
24890 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24891 ecode2 = SWIG_AsVal_int(obj1, &val2);
24892 if (!SWIG_IsOK(ecode2)) {
24893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24894 }
24895 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24896 {
24897 PyThreadState* __tstate = wxPyBeginAllowThreads();
24898 result = (arg1)->GetPrevWeekDay(arg2);
24899 wxPyEndAllowThreads(__tstate);
24900 if (PyErr_Occurred()) SWIG_fail;
24901 }
24902 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24903 return resultobj;
24904 fail:
24905 return NULL;
24906 }
24907
24908
24909 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24910 PyObject *resultobj = 0;
24911 wxDateTime *arg1 = (wxDateTime *) 0 ;
24912 wxDateTime::WeekDay arg2 ;
24913 int arg3 = (int) 1 ;
24914 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24915 int arg5 = (int) wxDateTime::Inv_Year ;
24916 bool result;
24917 void *argp1 = 0 ;
24918 int res1 = 0 ;
24919 int val2 ;
24920 int ecode2 = 0 ;
24921 int val3 ;
24922 int ecode3 = 0 ;
24923 int val4 ;
24924 int ecode4 = 0 ;
24925 int val5 ;
24926 int ecode5 = 0 ;
24927 PyObject * obj0 = 0 ;
24928 PyObject * obj1 = 0 ;
24929 PyObject * obj2 = 0 ;
24930 PyObject * obj3 = 0 ;
24931 PyObject * obj4 = 0 ;
24932 char * kwnames[] = {
24933 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
24934 };
24935
24936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24938 if (!SWIG_IsOK(res1)) {
24939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24940 }
24941 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24942 ecode2 = SWIG_AsVal_int(obj1, &val2);
24943 if (!SWIG_IsOK(ecode2)) {
24944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24945 }
24946 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24947 if (obj2) {
24948 ecode3 = SWIG_AsVal_int(obj2, &val3);
24949 if (!SWIG_IsOK(ecode3)) {
24950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
24951 }
24952 arg3 = static_cast< int >(val3);
24953 }
24954 if (obj3) {
24955 ecode4 = SWIG_AsVal_int(obj3, &val4);
24956 if (!SWIG_IsOK(ecode4)) {
24957 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
24958 }
24959 arg4 = static_cast< wxDateTime::Month >(val4);
24960 }
24961 if (obj4) {
24962 ecode5 = SWIG_AsVal_int(obj4, &val5);
24963 if (!SWIG_IsOK(ecode5)) {
24964 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
24965 }
24966 arg5 = static_cast< int >(val5);
24967 }
24968 {
24969 PyThreadState* __tstate = wxPyBeginAllowThreads();
24970 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
24971 wxPyEndAllowThreads(__tstate);
24972 if (PyErr_Occurred()) SWIG_fail;
24973 }
24974 {
24975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24976 }
24977 return resultobj;
24978 fail:
24979 return NULL;
24980 }
24981
24982
24983 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24984 PyObject *resultobj = 0;
24985 wxDateTime *arg1 = (wxDateTime *) 0 ;
24986 wxDateTime::WeekDay arg2 ;
24987 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24988 int arg4 = (int) wxDateTime::Inv_Year ;
24989 bool result;
24990 void *argp1 = 0 ;
24991 int res1 = 0 ;
24992 int val2 ;
24993 int ecode2 = 0 ;
24994 int val3 ;
24995 int ecode3 = 0 ;
24996 int val4 ;
24997 int ecode4 = 0 ;
24998 PyObject * obj0 = 0 ;
24999 PyObject * obj1 = 0 ;
25000 PyObject * obj2 = 0 ;
25001 PyObject * obj3 = 0 ;
25002 char * kwnames[] = {
25003 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25004 };
25005
25006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25008 if (!SWIG_IsOK(res1)) {
25009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25010 }
25011 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25012 ecode2 = SWIG_AsVal_int(obj1, &val2);
25013 if (!SWIG_IsOK(ecode2)) {
25014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25015 }
25016 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25017 if (obj2) {
25018 ecode3 = SWIG_AsVal_int(obj2, &val3);
25019 if (!SWIG_IsOK(ecode3)) {
25020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25021 }
25022 arg3 = static_cast< wxDateTime::Month >(val3);
25023 }
25024 if (obj3) {
25025 ecode4 = SWIG_AsVal_int(obj3, &val4);
25026 if (!SWIG_IsOK(ecode4)) {
25027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25028 }
25029 arg4 = static_cast< int >(val4);
25030 }
25031 {
25032 PyThreadState* __tstate = wxPyBeginAllowThreads();
25033 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25034 wxPyEndAllowThreads(__tstate);
25035 if (PyErr_Occurred()) SWIG_fail;
25036 }
25037 {
25038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25039 }
25040 return resultobj;
25041 fail:
25042 return NULL;
25043 }
25044
25045
25046 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25047 PyObject *resultobj = 0;
25048 wxDateTime *arg1 = (wxDateTime *) 0 ;
25049 wxDateTime::WeekDay arg2 ;
25050 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25051 int arg4 = (int) wxDateTime::Inv_Year ;
25052 wxDateTime result;
25053 void *argp1 = 0 ;
25054 int res1 = 0 ;
25055 int val2 ;
25056 int ecode2 = 0 ;
25057 int val3 ;
25058 int ecode3 = 0 ;
25059 int val4 ;
25060 int ecode4 = 0 ;
25061 PyObject * obj0 = 0 ;
25062 PyObject * obj1 = 0 ;
25063 PyObject * obj2 = 0 ;
25064 PyObject * obj3 = 0 ;
25065 char * kwnames[] = {
25066 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25067 };
25068
25069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25071 if (!SWIG_IsOK(res1)) {
25072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25073 }
25074 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25075 ecode2 = SWIG_AsVal_int(obj1, &val2);
25076 if (!SWIG_IsOK(ecode2)) {
25077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25078 }
25079 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25080 if (obj2) {
25081 ecode3 = SWIG_AsVal_int(obj2, &val3);
25082 if (!SWIG_IsOK(ecode3)) {
25083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25084 }
25085 arg3 = static_cast< wxDateTime::Month >(val3);
25086 }
25087 if (obj3) {
25088 ecode4 = SWIG_AsVal_int(obj3, &val4);
25089 if (!SWIG_IsOK(ecode4)) {
25090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25091 }
25092 arg4 = static_cast< int >(val4);
25093 }
25094 {
25095 PyThreadState* __tstate = wxPyBeginAllowThreads();
25096 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25101 return resultobj;
25102 fail:
25103 return NULL;
25104 }
25105
25106
25107 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25108 PyObject *resultobj = 0;
25109 wxDateTime *arg1 = (wxDateTime *) 0 ;
25110 int arg2 ;
25111 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25112 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25113 bool result;
25114 void *argp1 = 0 ;
25115 int res1 = 0 ;
25116 int val2 ;
25117 int ecode2 = 0 ;
25118 int val3 ;
25119 int ecode3 = 0 ;
25120 int val4 ;
25121 int ecode4 = 0 ;
25122 PyObject * obj0 = 0 ;
25123 PyObject * obj1 = 0 ;
25124 PyObject * obj2 = 0 ;
25125 PyObject * obj3 = 0 ;
25126 char * kwnames[] = {
25127 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25128 };
25129
25130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25132 if (!SWIG_IsOK(res1)) {
25133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25134 }
25135 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25136 ecode2 = SWIG_AsVal_int(obj1, &val2);
25137 if (!SWIG_IsOK(ecode2)) {
25138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25139 }
25140 arg2 = static_cast< int >(val2);
25141 if (obj2) {
25142 ecode3 = SWIG_AsVal_int(obj2, &val3);
25143 if (!SWIG_IsOK(ecode3)) {
25144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25145 }
25146 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25147 }
25148 if (obj3) {
25149 ecode4 = SWIG_AsVal_int(obj3, &val4);
25150 if (!SWIG_IsOK(ecode4)) {
25151 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25152 }
25153 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25154 }
25155 {
25156 PyThreadState* __tstate = wxPyBeginAllowThreads();
25157 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 {
25162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25163 }
25164 return resultobj;
25165 fail:
25166 return NULL;
25167 }
25168
25169
25170 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25171 PyObject *resultobj = 0;
25172 wxDateTime *arg1 = (wxDateTime *) 0 ;
25173 int arg2 ;
25174 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25175 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25176 wxDateTime result;
25177 void *argp1 = 0 ;
25178 int res1 = 0 ;
25179 int val2 ;
25180 int ecode2 = 0 ;
25181 int val3 ;
25182 int ecode3 = 0 ;
25183 int val4 ;
25184 int ecode4 = 0 ;
25185 PyObject * obj0 = 0 ;
25186 PyObject * obj1 = 0 ;
25187 PyObject * obj2 = 0 ;
25188 PyObject * obj3 = 0 ;
25189 char * kwnames[] = {
25190 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25191 };
25192
25193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25195 if (!SWIG_IsOK(res1)) {
25196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25197 }
25198 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25199 ecode2 = SWIG_AsVal_int(obj1, &val2);
25200 if (!SWIG_IsOK(ecode2)) {
25201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25202 }
25203 arg2 = static_cast< int >(val2);
25204 if (obj2) {
25205 ecode3 = SWIG_AsVal_int(obj2, &val3);
25206 if (!SWIG_IsOK(ecode3)) {
25207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25208 }
25209 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25210 }
25211 if (obj3) {
25212 ecode4 = SWIG_AsVal_int(obj3, &val4);
25213 if (!SWIG_IsOK(ecode4)) {
25214 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25215 }
25216 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25217 }
25218 {
25219 PyThreadState* __tstate = wxPyBeginAllowThreads();
25220 result = (arg1)->GetWeek(arg2,arg3,arg4);
25221 wxPyEndAllowThreads(__tstate);
25222 if (PyErr_Occurred()) SWIG_fail;
25223 }
25224 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25225 return resultobj;
25226 fail:
25227 return NULL;
25228 }
25229
25230
25231 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25232 PyObject *resultobj = 0;
25233 int arg1 ;
25234 int arg2 ;
25235 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25236 wxDateTime result;
25237 int val1 ;
25238 int ecode1 = 0 ;
25239 int val2 ;
25240 int ecode2 = 0 ;
25241 int val3 ;
25242 int ecode3 = 0 ;
25243 PyObject * obj0 = 0 ;
25244 PyObject * obj1 = 0 ;
25245 PyObject * obj2 = 0 ;
25246 char * kwnames[] = {
25247 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25248 };
25249
25250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25251 ecode1 = SWIG_AsVal_int(obj0, &val1);
25252 if (!SWIG_IsOK(ecode1)) {
25253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25254 }
25255 arg1 = static_cast< int >(val1);
25256 ecode2 = SWIG_AsVal_int(obj1, &val2);
25257 if (!SWIG_IsOK(ecode2)) {
25258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25259 }
25260 arg2 = static_cast< int >(val2);
25261 if (obj2) {
25262 ecode3 = SWIG_AsVal_int(obj2, &val3);
25263 if (!SWIG_IsOK(ecode3)) {
25264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25265 }
25266 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25267 }
25268 {
25269 PyThreadState* __tstate = wxPyBeginAllowThreads();
25270 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25271 wxPyEndAllowThreads(__tstate);
25272 if (PyErr_Occurred()) SWIG_fail;
25273 }
25274 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25275 return resultobj;
25276 fail:
25277 return NULL;
25278 }
25279
25280
25281 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25282 PyObject *resultobj = 0;
25283 wxDateTime *arg1 = (wxDateTime *) 0 ;
25284 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25285 int arg3 = (int) wxDateTime::Inv_Year ;
25286 wxDateTime *result = 0 ;
25287 void *argp1 = 0 ;
25288 int res1 = 0 ;
25289 int val2 ;
25290 int ecode2 = 0 ;
25291 int val3 ;
25292 int ecode3 = 0 ;
25293 PyObject * obj0 = 0 ;
25294 PyObject * obj1 = 0 ;
25295 PyObject * obj2 = 0 ;
25296 char * kwnames[] = {
25297 (char *) "self",(char *) "month",(char *) "year", NULL
25298 };
25299
25300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25302 if (!SWIG_IsOK(res1)) {
25303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25304 }
25305 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25306 if (obj1) {
25307 ecode2 = SWIG_AsVal_int(obj1, &val2);
25308 if (!SWIG_IsOK(ecode2)) {
25309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25310 }
25311 arg2 = static_cast< wxDateTime::Month >(val2);
25312 }
25313 if (obj2) {
25314 ecode3 = SWIG_AsVal_int(obj2, &val3);
25315 if (!SWIG_IsOK(ecode3)) {
25316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25317 }
25318 arg3 = static_cast< int >(val3);
25319 }
25320 {
25321 PyThreadState* __tstate = wxPyBeginAllowThreads();
25322 {
25323 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25324 result = (wxDateTime *) &_result_ref;
25325 }
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25330 return resultobj;
25331 fail:
25332 return NULL;
25333 }
25334
25335
25336 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25337 PyObject *resultobj = 0;
25338 wxDateTime *arg1 = (wxDateTime *) 0 ;
25339 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25340 int arg3 = (int) wxDateTime::Inv_Year ;
25341 wxDateTime result;
25342 void *argp1 = 0 ;
25343 int res1 = 0 ;
25344 int val2 ;
25345 int ecode2 = 0 ;
25346 int val3 ;
25347 int ecode3 = 0 ;
25348 PyObject * obj0 = 0 ;
25349 PyObject * obj1 = 0 ;
25350 PyObject * obj2 = 0 ;
25351 char * kwnames[] = {
25352 (char *) "self",(char *) "month",(char *) "year", NULL
25353 };
25354
25355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25357 if (!SWIG_IsOK(res1)) {
25358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25359 }
25360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25361 if (obj1) {
25362 ecode2 = SWIG_AsVal_int(obj1, &val2);
25363 if (!SWIG_IsOK(ecode2)) {
25364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25365 }
25366 arg2 = static_cast< wxDateTime::Month >(val2);
25367 }
25368 if (obj2) {
25369 ecode3 = SWIG_AsVal_int(obj2, &val3);
25370 if (!SWIG_IsOK(ecode3)) {
25371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25372 }
25373 arg3 = static_cast< int >(val3);
25374 }
25375 {
25376 PyThreadState* __tstate = wxPyBeginAllowThreads();
25377 result = (arg1)->GetLastMonthDay(arg2,arg3);
25378 wxPyEndAllowThreads(__tstate);
25379 if (PyErr_Occurred()) SWIG_fail;
25380 }
25381 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25382 return resultobj;
25383 fail:
25384 return NULL;
25385 }
25386
25387
25388 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25389 PyObject *resultobj = 0;
25390 wxDateTime *arg1 = (wxDateTime *) 0 ;
25391 int arg2 ;
25392 wxDateTime *result = 0 ;
25393 void *argp1 = 0 ;
25394 int res1 = 0 ;
25395 int val2 ;
25396 int ecode2 = 0 ;
25397 PyObject * obj0 = 0 ;
25398 PyObject * obj1 = 0 ;
25399 char * kwnames[] = {
25400 (char *) "self",(char *) "yday", NULL
25401 };
25402
25403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25405 if (!SWIG_IsOK(res1)) {
25406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25407 }
25408 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25409 ecode2 = SWIG_AsVal_int(obj1, &val2);
25410 if (!SWIG_IsOK(ecode2)) {
25411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25412 }
25413 arg2 = static_cast< int >(val2);
25414 {
25415 PyThreadState* __tstate = wxPyBeginAllowThreads();
25416 {
25417 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25418 result = (wxDateTime *) &_result_ref;
25419 }
25420 wxPyEndAllowThreads(__tstate);
25421 if (PyErr_Occurred()) SWIG_fail;
25422 }
25423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25424 return resultobj;
25425 fail:
25426 return NULL;
25427 }
25428
25429
25430 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25431 PyObject *resultobj = 0;
25432 wxDateTime *arg1 = (wxDateTime *) 0 ;
25433 int arg2 ;
25434 wxDateTime result;
25435 void *argp1 = 0 ;
25436 int res1 = 0 ;
25437 int val2 ;
25438 int ecode2 = 0 ;
25439 PyObject * obj0 = 0 ;
25440 PyObject * obj1 = 0 ;
25441 char * kwnames[] = {
25442 (char *) "self",(char *) "yday", NULL
25443 };
25444
25445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25447 if (!SWIG_IsOK(res1)) {
25448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25449 }
25450 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25451 ecode2 = SWIG_AsVal_int(obj1, &val2);
25452 if (!SWIG_IsOK(ecode2)) {
25453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25454 }
25455 arg2 = static_cast< int >(val2);
25456 {
25457 PyThreadState* __tstate = wxPyBeginAllowThreads();
25458 result = (arg1)->GetYearDay(arg2);
25459 wxPyEndAllowThreads(__tstate);
25460 if (PyErr_Occurred()) SWIG_fail;
25461 }
25462 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25463 return resultobj;
25464 fail:
25465 return NULL;
25466 }
25467
25468
25469 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25470 PyObject *resultobj = 0;
25471 wxDateTime *arg1 = (wxDateTime *) 0 ;
25472 double result;
25473 void *argp1 = 0 ;
25474 int res1 = 0 ;
25475 PyObject *swig_obj[1] ;
25476
25477 if (!args) SWIG_fail;
25478 swig_obj[0] = args;
25479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25480 if (!SWIG_IsOK(res1)) {
25481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25482 }
25483 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25484 {
25485 PyThreadState* __tstate = wxPyBeginAllowThreads();
25486 result = (double)(arg1)->GetJulianDayNumber();
25487 wxPyEndAllowThreads(__tstate);
25488 if (PyErr_Occurred()) SWIG_fail;
25489 }
25490 resultobj = SWIG_From_double(static_cast< double >(result));
25491 return resultobj;
25492 fail:
25493 return NULL;
25494 }
25495
25496
25497 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25498 PyObject *resultobj = 0;
25499 wxDateTime *arg1 = (wxDateTime *) 0 ;
25500 double result;
25501 void *argp1 = 0 ;
25502 int res1 = 0 ;
25503 PyObject *swig_obj[1] ;
25504
25505 if (!args) SWIG_fail;
25506 swig_obj[0] = args;
25507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25508 if (!SWIG_IsOK(res1)) {
25509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25510 }
25511 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25512 {
25513 PyThreadState* __tstate = wxPyBeginAllowThreads();
25514 result = (double)(arg1)->GetJDN();
25515 wxPyEndAllowThreads(__tstate);
25516 if (PyErr_Occurred()) SWIG_fail;
25517 }
25518 resultobj = SWIG_From_double(static_cast< double >(result));
25519 return resultobj;
25520 fail:
25521 return NULL;
25522 }
25523
25524
25525 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(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_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25538 }
25539 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25540 {
25541 PyThreadState* __tstate = wxPyBeginAllowThreads();
25542 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
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_GetMJD(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_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25566 }
25567 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25568 {
25569 PyThreadState* __tstate = wxPyBeginAllowThreads();
25570 result = (double)(arg1)->GetMJD();
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_GetRataDie(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_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25594 }
25595 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 result = (double)(arg1)->GetRataDie();
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_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25610 PyObject *resultobj = 0;
25611 wxDateTime *arg1 = (wxDateTime *) 0 ;
25612 wxDateTime::TimeZone *arg2 = 0 ;
25613 bool arg3 = (bool) false ;
25614 wxDateTime result;
25615 void *argp1 = 0 ;
25616 int res1 = 0 ;
25617 bool temp2 = false ;
25618 bool val3 ;
25619 int ecode3 = 0 ;
25620 PyObject * obj0 = 0 ;
25621 PyObject * obj1 = 0 ;
25622 PyObject * obj2 = 0 ;
25623 char * kwnames[] = {
25624 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25625 };
25626
25627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25629 if (!SWIG_IsOK(res1)) {
25630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25631 }
25632 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25633 {
25634 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25635 temp2 = true;
25636 }
25637 if (obj2) {
25638 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25639 if (!SWIG_IsOK(ecode3)) {
25640 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25641 }
25642 arg3 = static_cast< bool >(val3);
25643 }
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25651 {
25652 if (temp2) delete arg2;
25653 }
25654 return resultobj;
25655 fail:
25656 {
25657 if (temp2) delete arg2;
25658 }
25659 return NULL;
25660 }
25661
25662
25663 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25664 PyObject *resultobj = 0;
25665 wxDateTime *arg1 = (wxDateTime *) 0 ;
25666 wxDateTime::TimeZone *arg2 = 0 ;
25667 bool arg3 = (bool) false ;
25668 wxDateTime *result = 0 ;
25669 void *argp1 = 0 ;
25670 int res1 = 0 ;
25671 bool temp2 = false ;
25672 bool val3 ;
25673 int ecode3 = 0 ;
25674 PyObject * obj0 = 0 ;
25675 PyObject * obj1 = 0 ;
25676 PyObject * obj2 = 0 ;
25677 char * kwnames[] = {
25678 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25679 };
25680
25681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25683 if (!SWIG_IsOK(res1)) {
25684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25685 }
25686 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25687 {
25688 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25689 temp2 = true;
25690 }
25691 if (obj2) {
25692 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25693 if (!SWIG_IsOK(ecode3)) {
25694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25695 }
25696 arg3 = static_cast< bool >(val3);
25697 }
25698 {
25699 PyThreadState* __tstate = wxPyBeginAllowThreads();
25700 {
25701 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25702 result = (wxDateTime *) &_result_ref;
25703 }
25704 wxPyEndAllowThreads(__tstate);
25705 if (PyErr_Occurred()) SWIG_fail;
25706 }
25707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25708 {
25709 if (temp2) delete arg2;
25710 }
25711 return resultobj;
25712 fail:
25713 {
25714 if (temp2) delete arg2;
25715 }
25716 return NULL;
25717 }
25718
25719
25720 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25721 PyObject *resultobj = 0;
25722 wxDateTime *arg1 = (wxDateTime *) 0 ;
25723 wxDateTime::TimeZone *arg2 = 0 ;
25724 bool arg3 = (bool) false ;
25725 wxDateTime result;
25726 void *argp1 = 0 ;
25727 int res1 = 0 ;
25728 bool temp2 = false ;
25729 bool val3 ;
25730 int ecode3 = 0 ;
25731 PyObject * obj0 = 0 ;
25732 PyObject * obj1 = 0 ;
25733 PyObject * obj2 = 0 ;
25734 char * kwnames[] = {
25735 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25736 };
25737
25738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25740 if (!SWIG_IsOK(res1)) {
25741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25742 }
25743 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25744 {
25745 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25746 temp2 = true;
25747 }
25748 if (obj2) {
25749 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25750 if (!SWIG_IsOK(ecode3)) {
25751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25752 }
25753 arg3 = static_cast< bool >(val3);
25754 }
25755 {
25756 PyThreadState* __tstate = wxPyBeginAllowThreads();
25757 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25758 wxPyEndAllowThreads(__tstate);
25759 if (PyErr_Occurred()) SWIG_fail;
25760 }
25761 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25762 {
25763 if (temp2) delete arg2;
25764 }
25765 return resultobj;
25766 fail:
25767 {
25768 if (temp2) delete arg2;
25769 }
25770 return NULL;
25771 }
25772
25773
25774 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25775 PyObject *resultobj = 0;
25776 wxDateTime *arg1 = (wxDateTime *) 0 ;
25777 wxDateTime::TimeZone *arg2 = 0 ;
25778 bool arg3 = (bool) false ;
25779 wxDateTime *result = 0 ;
25780 void *argp1 = 0 ;
25781 int res1 = 0 ;
25782 bool temp2 = false ;
25783 bool val3 ;
25784 int ecode3 = 0 ;
25785 PyObject * obj0 = 0 ;
25786 PyObject * obj1 = 0 ;
25787 PyObject * obj2 = 0 ;
25788 char * kwnames[] = {
25789 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25790 };
25791
25792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25794 if (!SWIG_IsOK(res1)) {
25795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25796 }
25797 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25798 {
25799 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25800 temp2 = true;
25801 }
25802 if (obj2) {
25803 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25804 if (!SWIG_IsOK(ecode3)) {
25805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25806 }
25807 arg3 = static_cast< bool >(val3);
25808 }
25809 {
25810 PyThreadState* __tstate = wxPyBeginAllowThreads();
25811 {
25812 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25813 result = (wxDateTime *) &_result_ref;
25814 }
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25819 {
25820 if (temp2) delete arg2;
25821 }
25822 return resultobj;
25823 fail:
25824 {
25825 if (temp2) delete arg2;
25826 }
25827 return NULL;
25828 }
25829
25830
25831 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25832 PyObject *resultobj = 0;
25833 wxDateTime *arg1 = (wxDateTime *) 0 ;
25834 bool arg2 = (bool) false ;
25835 wxDateTime result;
25836 void *argp1 = 0 ;
25837 int res1 = 0 ;
25838 bool val2 ;
25839 int ecode2 = 0 ;
25840 PyObject * obj0 = 0 ;
25841 PyObject * obj1 = 0 ;
25842 char * kwnames[] = {
25843 (char *) "self",(char *) "noDST", NULL
25844 };
25845
25846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25848 if (!SWIG_IsOK(res1)) {
25849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25850 }
25851 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25852 if (obj1) {
25853 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25854 if (!SWIG_IsOK(ecode2)) {
25855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25856 }
25857 arg2 = static_cast< bool >(val2);
25858 }
25859 {
25860 PyThreadState* __tstate = wxPyBeginAllowThreads();
25861 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25862 wxPyEndAllowThreads(__tstate);
25863 if (PyErr_Occurred()) SWIG_fail;
25864 }
25865 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25866 return resultobj;
25867 fail:
25868 return NULL;
25869 }
25870
25871
25872 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25873 PyObject *resultobj = 0;
25874 wxDateTime *arg1 = (wxDateTime *) 0 ;
25875 bool arg2 = (bool) false ;
25876 wxDateTime *result = 0 ;
25877 void *argp1 = 0 ;
25878 int res1 = 0 ;
25879 bool val2 ;
25880 int ecode2 = 0 ;
25881 PyObject * obj0 = 0 ;
25882 PyObject * obj1 = 0 ;
25883 char * kwnames[] = {
25884 (char *) "self",(char *) "noDST", NULL
25885 };
25886
25887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25889 if (!SWIG_IsOK(res1)) {
25890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25891 }
25892 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25893 if (obj1) {
25894 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25895 if (!SWIG_IsOK(ecode2)) {
25896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25897 }
25898 arg2 = static_cast< bool >(val2);
25899 }
25900 {
25901 PyThreadState* __tstate = wxPyBeginAllowThreads();
25902 {
25903 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25904 result = (wxDateTime *) &_result_ref;
25905 }
25906 wxPyEndAllowThreads(__tstate);
25907 if (PyErr_Occurred()) SWIG_fail;
25908 }
25909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25910 return resultobj;
25911 fail:
25912 return NULL;
25913 }
25914
25915
25916 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25917 PyObject *resultobj = 0;
25918 wxDateTime *arg1 = (wxDateTime *) 0 ;
25919 bool arg2 = (bool) false ;
25920 wxDateTime result;
25921 void *argp1 = 0 ;
25922 int res1 = 0 ;
25923 bool val2 ;
25924 int ecode2 = 0 ;
25925 PyObject * obj0 = 0 ;
25926 PyObject * obj1 = 0 ;
25927 char * kwnames[] = {
25928 (char *) "self",(char *) "noDST", NULL
25929 };
25930
25931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25933 if (!SWIG_IsOK(res1)) {
25934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25935 }
25936 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25937 if (obj1) {
25938 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25939 if (!SWIG_IsOK(ecode2)) {
25940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
25941 }
25942 arg2 = static_cast< bool >(val2);
25943 }
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25958 PyObject *resultobj = 0;
25959 wxDateTime *arg1 = (wxDateTime *) 0 ;
25960 bool arg2 = (bool) false ;
25961 wxDateTime *result = 0 ;
25962 void *argp1 = 0 ;
25963 int res1 = 0 ;
25964 bool val2 ;
25965 int ecode2 = 0 ;
25966 PyObject * obj0 = 0 ;
25967 PyObject * obj1 = 0 ;
25968 char * kwnames[] = {
25969 (char *) "self",(char *) "noDST", NULL
25970 };
25971
25972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
25973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25974 if (!SWIG_IsOK(res1)) {
25975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
25976 }
25977 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25978 if (obj1) {
25979 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25980 if (!SWIG_IsOK(ecode2)) {
25981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
25982 }
25983 arg2 = static_cast< bool >(val2);
25984 }
25985 {
25986 PyThreadState* __tstate = wxPyBeginAllowThreads();
25987 {
25988 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
25989 result = (wxDateTime *) &_result_ref;
25990 }
25991 wxPyEndAllowThreads(__tstate);
25992 if (PyErr_Occurred()) SWIG_fail;
25993 }
25994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj = 0;
26003 wxDateTime *arg1 = (wxDateTime *) 0 ;
26004 bool arg2 = (bool) false ;
26005 wxDateTime result;
26006 void *argp1 = 0 ;
26007 int res1 = 0 ;
26008 bool val2 ;
26009 int ecode2 = 0 ;
26010 PyObject * obj0 = 0 ;
26011 PyObject * obj1 = 0 ;
26012 char * kwnames[] = {
26013 (char *) "self",(char *) "noDST", NULL
26014 };
26015
26016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26018 if (!SWIG_IsOK(res1)) {
26019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26020 }
26021 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26022 if (obj1) {
26023 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26024 if (!SWIG_IsOK(ecode2)) {
26025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26026 }
26027 arg2 = static_cast< bool >(val2);
26028 }
26029 {
26030 PyThreadState* __tstate = wxPyBeginAllowThreads();
26031 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26036 return resultobj;
26037 fail:
26038 return NULL;
26039 }
26040
26041
26042 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26043 PyObject *resultobj = 0;
26044 wxDateTime *arg1 = (wxDateTime *) 0 ;
26045 bool arg2 = (bool) false ;
26046 wxDateTime *result = 0 ;
26047 void *argp1 = 0 ;
26048 int res1 = 0 ;
26049 bool val2 ;
26050 int ecode2 = 0 ;
26051 PyObject * obj0 = 0 ;
26052 PyObject * obj1 = 0 ;
26053 char * kwnames[] = {
26054 (char *) "self",(char *) "noDST", NULL
26055 };
26056
26057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26059 if (!SWIG_IsOK(res1)) {
26060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26061 }
26062 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26063 if (obj1) {
26064 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26065 if (!SWIG_IsOK(ecode2)) {
26066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26067 }
26068 arg2 = static_cast< bool >(val2);
26069 }
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 {
26073 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26074 result = (wxDateTime *) &_result_ref;
26075 }
26076 wxPyEndAllowThreads(__tstate);
26077 if (PyErr_Occurred()) SWIG_fail;
26078 }
26079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26080 return resultobj;
26081 fail:
26082 return NULL;
26083 }
26084
26085
26086 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26087 PyObject *resultobj = 0;
26088 wxDateTime *arg1 = (wxDateTime *) 0 ;
26089 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26090 int result;
26091 void *argp1 = 0 ;
26092 int res1 = 0 ;
26093 int val2 ;
26094 int ecode2 = 0 ;
26095 PyObject * obj0 = 0 ;
26096 PyObject * obj1 = 0 ;
26097 char * kwnames[] = {
26098 (char *) "self",(char *) "country", NULL
26099 };
26100
26101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26103 if (!SWIG_IsOK(res1)) {
26104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26105 }
26106 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26107 if (obj1) {
26108 ecode2 = SWIG_AsVal_int(obj1, &val2);
26109 if (!SWIG_IsOK(ecode2)) {
26110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26111 }
26112 arg2 = static_cast< wxDateTime::Country >(val2);
26113 }
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 result = (int)(arg1)->IsDST(arg2);
26117 wxPyEndAllowThreads(__tstate);
26118 if (PyErr_Occurred()) SWIG_fail;
26119 }
26120 resultobj = SWIG_From_int(static_cast< int >(result));
26121 return resultobj;
26122 fail:
26123 return NULL;
26124 }
26125
26126
26127 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26128 PyObject *resultobj = 0;
26129 wxDateTime *arg1 = (wxDateTime *) 0 ;
26130 bool result;
26131 void *argp1 = 0 ;
26132 int res1 = 0 ;
26133 PyObject *swig_obj[1] ;
26134
26135 if (!args) SWIG_fail;
26136 swig_obj[0] = args;
26137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26138 if (!SWIG_IsOK(res1)) {
26139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26140 }
26141 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26142 {
26143 PyThreadState* __tstate = wxPyBeginAllowThreads();
26144 result = (bool)((wxDateTime const *)arg1)->IsValid();
26145 wxPyEndAllowThreads(__tstate);
26146 if (PyErr_Occurred()) SWIG_fail;
26147 }
26148 {
26149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26150 }
26151 return resultobj;
26152 fail:
26153 return NULL;
26154 }
26155
26156
26157 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26158 PyObject *resultobj = 0;
26159 wxDateTime *arg1 = (wxDateTime *) 0 ;
26160 time_t result;
26161 void *argp1 = 0 ;
26162 int res1 = 0 ;
26163 PyObject *swig_obj[1] ;
26164
26165 if (!args) SWIG_fail;
26166 swig_obj[0] = args;
26167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26168 if (!SWIG_IsOK(res1)) {
26169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26170 }
26171 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26172 {
26173 PyThreadState* __tstate = wxPyBeginAllowThreads();
26174 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26175 wxPyEndAllowThreads(__tstate);
26176 if (PyErr_Occurred()) SWIG_fail;
26177 }
26178 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26179 return resultobj;
26180 fail:
26181 return NULL;
26182 }
26183
26184
26185 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26186 PyObject *resultobj = 0;
26187 wxDateTime *arg1 = (wxDateTime *) 0 ;
26188 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26189 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26190 int result;
26191 void *argp1 = 0 ;
26192 int res1 = 0 ;
26193 bool temp2 = false ;
26194 PyObject * obj0 = 0 ;
26195 PyObject * obj1 = 0 ;
26196 char * kwnames[] = {
26197 (char *) "self",(char *) "tz", NULL
26198 };
26199
26200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26202 if (!SWIG_IsOK(res1)) {
26203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26204 }
26205 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26206 if (obj1) {
26207 {
26208 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26209 temp2 = true;
26210 }
26211 }
26212 {
26213 PyThreadState* __tstate = wxPyBeginAllowThreads();
26214 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26215 wxPyEndAllowThreads(__tstate);
26216 if (PyErr_Occurred()) SWIG_fail;
26217 }
26218 resultobj = SWIG_From_int(static_cast< int >(result));
26219 {
26220 if (temp2) delete arg2;
26221 }
26222 return resultobj;
26223 fail:
26224 {
26225 if (temp2) delete arg2;
26226 }
26227 return NULL;
26228 }
26229
26230
26231 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26232 PyObject *resultobj = 0;
26233 wxDateTime *arg1 = (wxDateTime *) 0 ;
26234 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26235 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26236 wxDateTime::Month result;
26237 void *argp1 = 0 ;
26238 int res1 = 0 ;
26239 bool temp2 = false ;
26240 PyObject * obj0 = 0 ;
26241 PyObject * obj1 = 0 ;
26242 char * kwnames[] = {
26243 (char *) "self",(char *) "tz", NULL
26244 };
26245
26246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26248 if (!SWIG_IsOK(res1)) {
26249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26250 }
26251 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26252 if (obj1) {
26253 {
26254 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26255 temp2 = true;
26256 }
26257 }
26258 {
26259 PyThreadState* __tstate = wxPyBeginAllowThreads();
26260 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26261 wxPyEndAllowThreads(__tstate);
26262 if (PyErr_Occurred()) SWIG_fail;
26263 }
26264 resultobj = SWIG_From_int(static_cast< int >(result));
26265 {
26266 if (temp2) delete arg2;
26267 }
26268 return resultobj;
26269 fail:
26270 {
26271 if (temp2) delete arg2;
26272 }
26273 return NULL;
26274 }
26275
26276
26277 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26278 PyObject *resultobj = 0;
26279 wxDateTime *arg1 = (wxDateTime *) 0 ;
26280 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26281 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26282 int result;
26283 void *argp1 = 0 ;
26284 int res1 = 0 ;
26285 bool temp2 = false ;
26286 PyObject * obj0 = 0 ;
26287 PyObject * obj1 = 0 ;
26288 char * kwnames[] = {
26289 (char *) "self",(char *) "tz", NULL
26290 };
26291
26292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26294 if (!SWIG_IsOK(res1)) {
26295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26296 }
26297 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26298 if (obj1) {
26299 {
26300 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26301 temp2 = true;
26302 }
26303 }
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 resultobj = SWIG_From_int(static_cast< int >(result));
26311 {
26312 if (temp2) delete arg2;
26313 }
26314 return resultobj;
26315 fail:
26316 {
26317 if (temp2) delete arg2;
26318 }
26319 return NULL;
26320 }
26321
26322
26323 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26324 PyObject *resultobj = 0;
26325 wxDateTime *arg1 = (wxDateTime *) 0 ;
26326 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26327 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26328 wxDateTime::WeekDay result;
26329 void *argp1 = 0 ;
26330 int res1 = 0 ;
26331 bool temp2 = false ;
26332 PyObject * obj0 = 0 ;
26333 PyObject * obj1 = 0 ;
26334 char * kwnames[] = {
26335 (char *) "self",(char *) "tz", NULL
26336 };
26337
26338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26340 if (!SWIG_IsOK(res1)) {
26341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26342 }
26343 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26344 if (obj1) {
26345 {
26346 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26347 temp2 = true;
26348 }
26349 }
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_From_int(static_cast< int >(result));
26357 {
26358 if (temp2) delete arg2;
26359 }
26360 return resultobj;
26361 fail:
26362 {
26363 if (temp2) delete arg2;
26364 }
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26370 PyObject *resultobj = 0;
26371 wxDateTime *arg1 = (wxDateTime *) 0 ;
26372 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26373 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26374 int result;
26375 void *argp1 = 0 ;
26376 int res1 = 0 ;
26377 bool temp2 = false ;
26378 PyObject * obj0 = 0 ;
26379 PyObject * obj1 = 0 ;
26380 char * kwnames[] = {
26381 (char *) "self",(char *) "tz", NULL
26382 };
26383
26384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26386 if (!SWIG_IsOK(res1)) {
26387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26388 }
26389 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26390 if (obj1) {
26391 {
26392 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26393 temp2 = true;
26394 }
26395 }
26396 {
26397 PyThreadState* __tstate = wxPyBeginAllowThreads();
26398 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26399 wxPyEndAllowThreads(__tstate);
26400 if (PyErr_Occurred()) SWIG_fail;
26401 }
26402 resultobj = SWIG_From_int(static_cast< int >(result));
26403 {
26404 if (temp2) delete arg2;
26405 }
26406 return resultobj;
26407 fail:
26408 {
26409 if (temp2) delete arg2;
26410 }
26411 return NULL;
26412 }
26413
26414
26415 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26416 PyObject *resultobj = 0;
26417 wxDateTime *arg1 = (wxDateTime *) 0 ;
26418 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26419 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26420 int result;
26421 void *argp1 = 0 ;
26422 int res1 = 0 ;
26423 bool temp2 = false ;
26424 PyObject * obj0 = 0 ;
26425 PyObject * obj1 = 0 ;
26426 char * kwnames[] = {
26427 (char *) "self",(char *) "tz", NULL
26428 };
26429
26430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26432 if (!SWIG_IsOK(res1)) {
26433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26434 }
26435 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26436 if (obj1) {
26437 {
26438 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26439 temp2 = true;
26440 }
26441 }
26442 {
26443 PyThreadState* __tstate = wxPyBeginAllowThreads();
26444 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26445 wxPyEndAllowThreads(__tstate);
26446 if (PyErr_Occurred()) SWIG_fail;
26447 }
26448 resultobj = SWIG_From_int(static_cast< int >(result));
26449 {
26450 if (temp2) delete arg2;
26451 }
26452 return resultobj;
26453 fail:
26454 {
26455 if (temp2) delete arg2;
26456 }
26457 return NULL;
26458 }
26459
26460
26461 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26462 PyObject *resultobj = 0;
26463 wxDateTime *arg1 = (wxDateTime *) 0 ;
26464 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26465 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26466 int result;
26467 void *argp1 = 0 ;
26468 int res1 = 0 ;
26469 bool temp2 = false ;
26470 PyObject * obj0 = 0 ;
26471 PyObject * obj1 = 0 ;
26472 char * kwnames[] = {
26473 (char *) "self",(char *) "tz", NULL
26474 };
26475
26476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26478 if (!SWIG_IsOK(res1)) {
26479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26480 }
26481 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26482 if (obj1) {
26483 {
26484 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26485 temp2 = true;
26486 }
26487 }
26488 {
26489 PyThreadState* __tstate = wxPyBeginAllowThreads();
26490 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26491 wxPyEndAllowThreads(__tstate);
26492 if (PyErr_Occurred()) SWIG_fail;
26493 }
26494 resultobj = SWIG_From_int(static_cast< int >(result));
26495 {
26496 if (temp2) delete arg2;
26497 }
26498 return resultobj;
26499 fail:
26500 {
26501 if (temp2) delete arg2;
26502 }
26503 return NULL;
26504 }
26505
26506
26507 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26508 PyObject *resultobj = 0;
26509 wxDateTime *arg1 = (wxDateTime *) 0 ;
26510 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26511 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26512 int result;
26513 void *argp1 = 0 ;
26514 int res1 = 0 ;
26515 bool temp2 = false ;
26516 PyObject * obj0 = 0 ;
26517 PyObject * obj1 = 0 ;
26518 char * kwnames[] = {
26519 (char *) "self",(char *) "tz", NULL
26520 };
26521
26522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26524 if (!SWIG_IsOK(res1)) {
26525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26526 }
26527 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26528 if (obj1) {
26529 {
26530 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26531 temp2 = true;
26532 }
26533 }
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 resultobj = SWIG_From_int(static_cast< int >(result));
26541 {
26542 if (temp2) delete arg2;
26543 }
26544 return resultobj;
26545 fail:
26546 {
26547 if (temp2) delete arg2;
26548 }
26549 return NULL;
26550 }
26551
26552
26553 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26554 PyObject *resultobj = 0;
26555 wxDateTime *arg1 = (wxDateTime *) 0 ;
26556 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26557 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26558 int result;
26559 void *argp1 = 0 ;
26560 int res1 = 0 ;
26561 bool temp2 = false ;
26562 PyObject * obj0 = 0 ;
26563 PyObject * obj1 = 0 ;
26564 char * kwnames[] = {
26565 (char *) "self",(char *) "tz", NULL
26566 };
26567
26568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26570 if (!SWIG_IsOK(res1)) {
26571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26572 }
26573 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26574 if (obj1) {
26575 {
26576 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26577 temp2 = true;
26578 }
26579 }
26580 {
26581 PyThreadState* __tstate = wxPyBeginAllowThreads();
26582 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 resultobj = SWIG_From_int(static_cast< int >(result));
26587 {
26588 if (temp2) delete arg2;
26589 }
26590 return resultobj;
26591 fail:
26592 {
26593 if (temp2) delete arg2;
26594 }
26595 return NULL;
26596 }
26597
26598
26599 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26600 PyObject *resultobj = 0;
26601 wxDateTime *arg1 = (wxDateTime *) 0 ;
26602 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26603 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26604 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26605 int result;
26606 void *argp1 = 0 ;
26607 int res1 = 0 ;
26608 int val2 ;
26609 int ecode2 = 0 ;
26610 bool temp3 = false ;
26611 PyObject * obj0 = 0 ;
26612 PyObject * obj1 = 0 ;
26613 PyObject * obj2 = 0 ;
26614 char * kwnames[] = {
26615 (char *) "self",(char *) "flags",(char *) "tz", NULL
26616 };
26617
26618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26620 if (!SWIG_IsOK(res1)) {
26621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26622 }
26623 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26624 if (obj1) {
26625 ecode2 = SWIG_AsVal_int(obj1, &val2);
26626 if (!SWIG_IsOK(ecode2)) {
26627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26628 }
26629 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26630 }
26631 if (obj2) {
26632 {
26633 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26634 temp3 = true;
26635 }
26636 }
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 resultobj = SWIG_From_int(static_cast< int >(result));
26644 {
26645 if (temp3) delete arg3;
26646 }
26647 return resultobj;
26648 fail:
26649 {
26650 if (temp3) delete arg3;
26651 }
26652 return NULL;
26653 }
26654
26655
26656 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26657 PyObject *resultobj = 0;
26658 wxDateTime *arg1 = (wxDateTime *) 0 ;
26659 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26660 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26661 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26662 int result;
26663 void *argp1 = 0 ;
26664 int res1 = 0 ;
26665 int val2 ;
26666 int ecode2 = 0 ;
26667 bool temp3 = false ;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670 PyObject * obj2 = 0 ;
26671 char * kwnames[] = {
26672 (char *) "self",(char *) "flags",(char *) "tz", NULL
26673 };
26674
26675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26677 if (!SWIG_IsOK(res1)) {
26678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26679 }
26680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26681 if (obj1) {
26682 ecode2 = SWIG_AsVal_int(obj1, &val2);
26683 if (!SWIG_IsOK(ecode2)) {
26684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26685 }
26686 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26687 }
26688 if (obj2) {
26689 {
26690 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26691 temp3 = true;
26692 }
26693 }
26694 {
26695 PyThreadState* __tstate = wxPyBeginAllowThreads();
26696 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26697 wxPyEndAllowThreads(__tstate);
26698 if (PyErr_Occurred()) SWIG_fail;
26699 }
26700 resultobj = SWIG_From_int(static_cast< int >(result));
26701 {
26702 if (temp3) delete arg3;
26703 }
26704 return resultobj;
26705 fail:
26706 {
26707 if (temp3) delete arg3;
26708 }
26709 return NULL;
26710 }
26711
26712
26713 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26714 PyObject *resultobj = 0;
26715 wxDateTime *arg1 = (wxDateTime *) 0 ;
26716 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26717 bool result;
26718 void *argp1 = 0 ;
26719 int res1 = 0 ;
26720 int val2 ;
26721 int ecode2 = 0 ;
26722 PyObject * obj0 = 0 ;
26723 PyObject * obj1 = 0 ;
26724 char * kwnames[] = {
26725 (char *) "self",(char *) "country", NULL
26726 };
26727
26728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26730 if (!SWIG_IsOK(res1)) {
26731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26732 }
26733 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26734 if (obj1) {
26735 ecode2 = SWIG_AsVal_int(obj1, &val2);
26736 if (!SWIG_IsOK(ecode2)) {
26737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26738 }
26739 arg2 = static_cast< wxDateTime::Country >(val2);
26740 }
26741 {
26742 PyThreadState* __tstate = wxPyBeginAllowThreads();
26743 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26744 wxPyEndAllowThreads(__tstate);
26745 if (PyErr_Occurred()) SWIG_fail;
26746 }
26747 {
26748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26749 }
26750 return resultobj;
26751 fail:
26752 return NULL;
26753 }
26754
26755
26756 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26757 PyObject *resultobj = 0;
26758 wxDateTime *arg1 = (wxDateTime *) 0 ;
26759 wxDateTime *arg2 = 0 ;
26760 bool result;
26761 void *argp1 = 0 ;
26762 int res1 = 0 ;
26763 void *argp2 = 0 ;
26764 int res2 = 0 ;
26765 PyObject * obj0 = 0 ;
26766 PyObject * obj1 = 0 ;
26767 char * kwnames[] = {
26768 (char *) "self",(char *) "datetime", NULL
26769 };
26770
26771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26773 if (!SWIG_IsOK(res1)) {
26774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26775 }
26776 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26777 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26778 if (!SWIG_IsOK(res2)) {
26779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26780 }
26781 if (!argp2) {
26782 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26783 }
26784 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 {
26792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26793 }
26794 return resultobj;
26795 fail:
26796 return NULL;
26797 }
26798
26799
26800 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26801 PyObject *resultobj = 0;
26802 wxDateTime *arg1 = (wxDateTime *) 0 ;
26803 wxDateTime *arg2 = 0 ;
26804 bool result;
26805 void *argp1 = 0 ;
26806 int res1 = 0 ;
26807 void *argp2 = 0 ;
26808 int res2 = 0 ;
26809 PyObject * obj0 = 0 ;
26810 PyObject * obj1 = 0 ;
26811 char * kwnames[] = {
26812 (char *) "self",(char *) "datetime", NULL
26813 };
26814
26815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26817 if (!SWIG_IsOK(res1)) {
26818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26819 }
26820 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26821 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26822 if (!SWIG_IsOK(res2)) {
26823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26824 }
26825 if (!argp2) {
26826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26827 }
26828 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26832 wxPyEndAllowThreads(__tstate);
26833 if (PyErr_Occurred()) SWIG_fail;
26834 }
26835 {
26836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26837 }
26838 return resultobj;
26839 fail:
26840 return NULL;
26841 }
26842
26843
26844 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26845 PyObject *resultobj = 0;
26846 wxDateTime *arg1 = (wxDateTime *) 0 ;
26847 wxDateTime *arg2 = 0 ;
26848 bool result;
26849 void *argp1 = 0 ;
26850 int res1 = 0 ;
26851 void *argp2 = 0 ;
26852 int res2 = 0 ;
26853 PyObject * obj0 = 0 ;
26854 PyObject * obj1 = 0 ;
26855 char * kwnames[] = {
26856 (char *) "self",(char *) "datetime", NULL
26857 };
26858
26859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26861 if (!SWIG_IsOK(res1)) {
26862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26863 }
26864 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26865 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26866 if (!SWIG_IsOK(res2)) {
26867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26868 }
26869 if (!argp2) {
26870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26871 }
26872 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26873 {
26874 PyThreadState* __tstate = wxPyBeginAllowThreads();
26875 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26876 wxPyEndAllowThreads(__tstate);
26877 if (PyErr_Occurred()) SWIG_fail;
26878 }
26879 {
26880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26881 }
26882 return resultobj;
26883 fail:
26884 return NULL;
26885 }
26886
26887
26888 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26889 PyObject *resultobj = 0;
26890 wxDateTime *arg1 = (wxDateTime *) 0 ;
26891 wxDateTime *arg2 = 0 ;
26892 wxDateTime *arg3 = 0 ;
26893 bool result;
26894 void *argp1 = 0 ;
26895 int res1 = 0 ;
26896 void *argp2 = 0 ;
26897 int res2 = 0 ;
26898 void *argp3 = 0 ;
26899 int res3 = 0 ;
26900 PyObject * obj0 = 0 ;
26901 PyObject * obj1 = 0 ;
26902 PyObject * obj2 = 0 ;
26903 char * kwnames[] = {
26904 (char *) "self",(char *) "t1",(char *) "t2", NULL
26905 };
26906
26907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26909 if (!SWIG_IsOK(res1)) {
26910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26911 }
26912 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26914 if (!SWIG_IsOK(res2)) {
26915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26916 }
26917 if (!argp2) {
26918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26919 }
26920 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26921 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
26922 if (!SWIG_IsOK(res3)) {
26923 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26924 }
26925 if (!argp3) {
26926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26927 }
26928 arg3 = reinterpret_cast< wxDateTime * >(argp3);
26929 {
26930 PyThreadState* __tstate = wxPyBeginAllowThreads();
26931 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
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_IsBetween(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_IsBetween",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_IsBetween" "', 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_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26972 }
26973 if (!argp2) {
26974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', 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_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
26980 }
26981 if (!argp3) {
26982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', 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)->IsBetween((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_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27001 PyObject *resultobj = 0;
27002 wxDateTime *arg1 = (wxDateTime *) 0 ;
27003 wxDateTime *arg2 = 0 ;
27004 bool result;
27005 void *argp1 = 0 ;
27006 int res1 = 0 ;
27007 void *argp2 = 0 ;
27008 int res2 = 0 ;
27009 PyObject * obj0 = 0 ;
27010 PyObject * obj1 = 0 ;
27011 char * kwnames[] = {
27012 (char *) "self",(char *) "dt", NULL
27013 };
27014
27015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27017 if (!SWIG_IsOK(res1)) {
27018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27019 }
27020 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27021 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27022 if (!SWIG_IsOK(res2)) {
27023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27024 }
27025 if (!argp2) {
27026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27027 }
27028 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27029 {
27030 PyThreadState* __tstate = wxPyBeginAllowThreads();
27031 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27032 wxPyEndAllowThreads(__tstate);
27033 if (PyErr_Occurred()) SWIG_fail;
27034 }
27035 {
27036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27037 }
27038 return resultobj;
27039 fail:
27040 return NULL;
27041 }
27042
27043
27044 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27045 PyObject *resultobj = 0;
27046 wxDateTime *arg1 = (wxDateTime *) 0 ;
27047 wxDateTime *arg2 = 0 ;
27048 bool result;
27049 void *argp1 = 0 ;
27050 int res1 = 0 ;
27051 void *argp2 = 0 ;
27052 int res2 = 0 ;
27053 PyObject * obj0 = 0 ;
27054 PyObject * obj1 = 0 ;
27055 char * kwnames[] = {
27056 (char *) "self",(char *) "dt", NULL
27057 };
27058
27059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27061 if (!SWIG_IsOK(res1)) {
27062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27063 }
27064 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27065 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27066 if (!SWIG_IsOK(res2)) {
27067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27068 }
27069 if (!argp2) {
27070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27071 }
27072 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27073 {
27074 PyThreadState* __tstate = wxPyBeginAllowThreads();
27075 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27076 wxPyEndAllowThreads(__tstate);
27077 if (PyErr_Occurred()) SWIG_fail;
27078 }
27079 {
27080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27081 }
27082 return resultobj;
27083 fail:
27084 return NULL;
27085 }
27086
27087
27088 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27089 PyObject *resultobj = 0;
27090 wxDateTime *arg1 = (wxDateTime *) 0 ;
27091 wxDateTime *arg2 = 0 ;
27092 wxTimeSpan *arg3 = 0 ;
27093 bool result;
27094 void *argp1 = 0 ;
27095 int res1 = 0 ;
27096 void *argp2 = 0 ;
27097 int res2 = 0 ;
27098 void *argp3 = 0 ;
27099 int res3 = 0 ;
27100 PyObject * obj0 = 0 ;
27101 PyObject * obj1 = 0 ;
27102 PyObject * obj2 = 0 ;
27103 char * kwnames[] = {
27104 (char *) "self",(char *) "dt",(char *) "ts", NULL
27105 };
27106
27107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27109 if (!SWIG_IsOK(res1)) {
27110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27111 }
27112 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27114 if (!SWIG_IsOK(res2)) {
27115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27116 }
27117 if (!argp2) {
27118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27119 }
27120 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27121 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27122 if (!SWIG_IsOK(res3)) {
27123 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27124 }
27125 if (!argp3) {
27126 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27127 }
27128 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27129 {
27130 PyThreadState* __tstate = wxPyBeginAllowThreads();
27131 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
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_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27145 PyObject *resultobj = 0;
27146 wxDateTime *arg1 = (wxDateTime *) 0 ;
27147 wxTimeSpan *arg2 = 0 ;
27148 wxDateTime *result = 0 ;
27149 void *argp1 = 0 ;
27150 int res1 = 0 ;
27151 void *argp2 = 0 ;
27152 int res2 = 0 ;
27153 PyObject * obj0 = 0 ;
27154 PyObject * obj1 = 0 ;
27155 char * kwnames[] = {
27156 (char *) "self",(char *) "diff", NULL
27157 };
27158
27159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27161 if (!SWIG_IsOK(res1)) {
27162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27163 }
27164 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27165 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27166 if (!SWIG_IsOK(res2)) {
27167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27168 }
27169 if (!argp2) {
27170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27171 }
27172 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27173 {
27174 PyThreadState* __tstate = wxPyBeginAllowThreads();
27175 {
27176 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27177 result = (wxDateTime *) &_result_ref;
27178 }
27179 wxPyEndAllowThreads(__tstate);
27180 if (PyErr_Occurred()) SWIG_fail;
27181 }
27182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27183 return resultobj;
27184 fail:
27185 return NULL;
27186 }
27187
27188
27189 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27190 PyObject *resultobj = 0;
27191 wxDateTime *arg1 = (wxDateTime *) 0 ;
27192 wxDateSpan *arg2 = 0 ;
27193 wxDateTime *result = 0 ;
27194 void *argp1 = 0 ;
27195 int res1 = 0 ;
27196 void *argp2 = 0 ;
27197 int res2 = 0 ;
27198 PyObject * obj0 = 0 ;
27199 PyObject * obj1 = 0 ;
27200 char * kwnames[] = {
27201 (char *) "self",(char *) "diff", NULL
27202 };
27203
27204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27206 if (!SWIG_IsOK(res1)) {
27207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27208 }
27209 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27210 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27211 if (!SWIG_IsOK(res2)) {
27212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27213 }
27214 if (!argp2) {
27215 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27216 }
27217 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27218 {
27219 PyThreadState* __tstate = wxPyBeginAllowThreads();
27220 {
27221 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27222 result = (wxDateTime *) &_result_ref;
27223 }
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27228 return resultobj;
27229 fail:
27230 return NULL;
27231 }
27232
27233
27234 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27235 PyObject *resultobj = 0;
27236 wxDateTime *arg1 = (wxDateTime *) 0 ;
27237 wxTimeSpan *arg2 = 0 ;
27238 wxDateTime *result = 0 ;
27239 void *argp1 = 0 ;
27240 int res1 = 0 ;
27241 void *argp2 = 0 ;
27242 int res2 = 0 ;
27243 PyObject * obj0 = 0 ;
27244 PyObject * obj1 = 0 ;
27245 char * kwnames[] = {
27246 (char *) "self",(char *) "diff", NULL
27247 };
27248
27249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27251 if (!SWIG_IsOK(res1)) {
27252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27253 }
27254 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27255 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27256 if (!SWIG_IsOK(res2)) {
27257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27258 }
27259 if (!argp2) {
27260 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27261 }
27262 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27263 {
27264 PyThreadState* __tstate = wxPyBeginAllowThreads();
27265 {
27266 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27267 result = (wxDateTime *) &_result_ref;
27268 }
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27273 return resultobj;
27274 fail:
27275 return NULL;
27276 }
27277
27278
27279 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27280 PyObject *resultobj = 0;
27281 wxDateTime *arg1 = (wxDateTime *) 0 ;
27282 wxDateSpan *arg2 = 0 ;
27283 wxDateTime *result = 0 ;
27284 void *argp1 = 0 ;
27285 int res1 = 0 ;
27286 void *argp2 = 0 ;
27287 int res2 = 0 ;
27288 PyObject * obj0 = 0 ;
27289 PyObject * obj1 = 0 ;
27290 char * kwnames[] = {
27291 (char *) "self",(char *) "diff", NULL
27292 };
27293
27294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27296 if (!SWIG_IsOK(res1)) {
27297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27298 }
27299 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27300 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27301 if (!SWIG_IsOK(res2)) {
27302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27303 }
27304 if (!argp2) {
27305 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27306 }
27307 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27308 {
27309 PyThreadState* __tstate = wxPyBeginAllowThreads();
27310 {
27311 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27312 result = (wxDateTime *) &_result_ref;
27313 }
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27318 return resultobj;
27319 fail:
27320 return NULL;
27321 }
27322
27323
27324 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27325 PyObject *resultobj = 0;
27326 wxDateTime *arg1 = (wxDateTime *) 0 ;
27327 wxDateTime *arg2 = 0 ;
27328 wxTimeSpan result;
27329 void *argp1 = 0 ;
27330 int res1 = 0 ;
27331 void *argp2 = 0 ;
27332 int res2 = 0 ;
27333 PyObject * obj0 = 0 ;
27334 PyObject * obj1 = 0 ;
27335 char * kwnames[] = {
27336 (char *) "self",(char *) "dt", NULL
27337 };
27338
27339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27341 if (!SWIG_IsOK(res1)) {
27342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27343 }
27344 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27345 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27346 if (!SWIG_IsOK(res2)) {
27347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27348 }
27349 if (!argp2) {
27350 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27351 }
27352 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27353 {
27354 PyThreadState* __tstate = wxPyBeginAllowThreads();
27355 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27356 wxPyEndAllowThreads(__tstate);
27357 if (PyErr_Occurred()) SWIG_fail;
27358 }
27359 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27360 return resultobj;
27361 fail:
27362 return NULL;
27363 }
27364
27365
27366 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27367 PyObject *resultobj = 0;
27368 wxDateTime *arg1 = (wxDateTime *) 0 ;
27369 wxTimeSpan *arg2 = 0 ;
27370 wxDateTime *result = 0 ;
27371 void *argp1 = 0 ;
27372 int res1 = 0 ;
27373 void *argp2 = 0 ;
27374 int res2 = 0 ;
27375
27376 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27378 if (!SWIG_IsOK(res1)) {
27379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27380 }
27381 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27382 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27383 if (!SWIG_IsOK(res2)) {
27384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27385 }
27386 if (!argp2) {
27387 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27388 }
27389 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 {
27393 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27394 result = (wxDateTime *) &_result_ref;
27395 }
27396 wxPyEndAllowThreads(__tstate);
27397 if (PyErr_Occurred()) SWIG_fail;
27398 }
27399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27400 return resultobj;
27401 fail:
27402 return NULL;
27403 }
27404
27405
27406 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27407 PyObject *resultobj = 0;
27408 wxDateTime *arg1 = (wxDateTime *) 0 ;
27409 wxDateSpan *arg2 = 0 ;
27410 wxDateTime *result = 0 ;
27411 void *argp1 = 0 ;
27412 int res1 = 0 ;
27413 void *argp2 = 0 ;
27414 int res2 = 0 ;
27415
27416 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27418 if (!SWIG_IsOK(res1)) {
27419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27420 }
27421 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27422 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27423 if (!SWIG_IsOK(res2)) {
27424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27425 }
27426 if (!argp2) {
27427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27428 }
27429 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27430 {
27431 PyThreadState* __tstate = wxPyBeginAllowThreads();
27432 {
27433 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27434 result = (wxDateTime *) &_result_ref;
27435 }
27436 wxPyEndAllowThreads(__tstate);
27437 if (PyErr_Occurred()) SWIG_fail;
27438 }
27439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27440 return resultobj;
27441 fail:
27442 return NULL;
27443 }
27444
27445
27446 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27447 int argc;
27448 PyObject *argv[3];
27449
27450 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27451 --argc;
27452 if (argc == 2) {
27453 int _v = 0;
27454 {
27455 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27456 _v = SWIG_CheckState(res);
27457 }
27458 if (!_v) goto check_1;
27459 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27460 }
27461 check_1:
27462
27463 if (argc == 2) {
27464 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27465 }
27466
27467 fail:
27468 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27469 return NULL;
27470 }
27471
27472
27473 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27474 PyObject *resultobj = 0;
27475 wxDateTime *arg1 = (wxDateTime *) 0 ;
27476 wxTimeSpan *arg2 = 0 ;
27477 wxDateTime *result = 0 ;
27478 void *argp1 = 0 ;
27479 int res1 = 0 ;
27480 void *argp2 = 0 ;
27481 int res2 = 0 ;
27482
27483 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27485 if (!SWIG_IsOK(res1)) {
27486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27487 }
27488 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27489 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27490 if (!SWIG_IsOK(res2)) {
27491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27492 }
27493 if (!argp2) {
27494 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27495 }
27496 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 {
27500 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27501 result = (wxDateTime *) &_result_ref;
27502 }
27503 wxPyEndAllowThreads(__tstate);
27504 if (PyErr_Occurred()) SWIG_fail;
27505 }
27506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27507 return resultobj;
27508 fail:
27509 return NULL;
27510 }
27511
27512
27513 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27514 PyObject *resultobj = 0;
27515 wxDateTime *arg1 = (wxDateTime *) 0 ;
27516 wxDateSpan *arg2 = 0 ;
27517 wxDateTime *result = 0 ;
27518 void *argp1 = 0 ;
27519 int res1 = 0 ;
27520 void *argp2 = 0 ;
27521 int res2 = 0 ;
27522
27523 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27525 if (!SWIG_IsOK(res1)) {
27526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27527 }
27528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27529 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27530 if (!SWIG_IsOK(res2)) {
27531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27532 }
27533 if (!argp2) {
27534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27535 }
27536 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 {
27540 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27541 result = (wxDateTime *) &_result_ref;
27542 }
27543 wxPyEndAllowThreads(__tstate);
27544 if (PyErr_Occurred()) SWIG_fail;
27545 }
27546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27547 return resultobj;
27548 fail:
27549 return NULL;
27550 }
27551
27552
27553 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27554 int argc;
27555 PyObject *argv[3];
27556
27557 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27558 --argc;
27559 if (argc == 2) {
27560 int _v = 0;
27561 {
27562 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27563 _v = SWIG_CheckState(res);
27564 }
27565 if (!_v) goto check_1;
27566 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27567 }
27568 check_1:
27569
27570 if (argc == 2) {
27571 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27572 }
27573
27574 fail:
27575 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27576 return NULL;
27577 }
27578
27579
27580 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27581 PyObject *resultobj = 0;
27582 wxDateTime *arg1 = (wxDateTime *) 0 ;
27583 wxTimeSpan *arg2 = 0 ;
27584 wxDateTime result;
27585 void *argp1 = 0 ;
27586 int res1 = 0 ;
27587 void *argp2 = 0 ;
27588 int res2 = 0 ;
27589
27590 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27592 if (!SWIG_IsOK(res1)) {
27593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27594 }
27595 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27596 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27597 if (!SWIG_IsOK(res2)) {
27598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27599 }
27600 if (!argp2) {
27601 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27602 }
27603 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27604 {
27605 PyThreadState* __tstate = wxPyBeginAllowThreads();
27606 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27607 wxPyEndAllowThreads(__tstate);
27608 if (PyErr_Occurred()) SWIG_fail;
27609 }
27610 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27618 PyObject *resultobj = 0;
27619 wxDateTime *arg1 = (wxDateTime *) 0 ;
27620 wxDateSpan *arg2 = 0 ;
27621 wxDateTime result;
27622 void *argp1 = 0 ;
27623 int res1 = 0 ;
27624 void *argp2 = 0 ;
27625 int res2 = 0 ;
27626
27627 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27629 if (!SWIG_IsOK(res1)) {
27630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27631 }
27632 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27633 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27634 if (!SWIG_IsOK(res2)) {
27635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27636 }
27637 if (!argp2) {
27638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27639 }
27640 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27641 {
27642 PyThreadState* __tstate = wxPyBeginAllowThreads();
27643 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27644 wxPyEndAllowThreads(__tstate);
27645 if (PyErr_Occurred()) SWIG_fail;
27646 }
27647 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27648 return resultobj;
27649 fail:
27650 return NULL;
27651 }
27652
27653
27654 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27655 int argc;
27656 PyObject *argv[3];
27657
27658 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27659 --argc;
27660 if (argc == 2) {
27661 int _v = 0;
27662 {
27663 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27664 _v = SWIG_CheckState(res);
27665 }
27666 if (!_v) goto check_1;
27667 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27668 }
27669 check_1:
27670
27671 if (argc == 2) {
27672 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27673 }
27674
27675 fail:
27676 Py_INCREF(Py_NotImplemented);
27677 return Py_NotImplemented;
27678 }
27679
27680
27681 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27682 PyObject *resultobj = 0;
27683 wxDateTime *arg1 = (wxDateTime *) 0 ;
27684 wxDateTime *arg2 = 0 ;
27685 wxTimeSpan result;
27686 void *argp1 = 0 ;
27687 int res1 = 0 ;
27688 void *argp2 = 0 ;
27689 int res2 = 0 ;
27690
27691 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27693 if (!SWIG_IsOK(res1)) {
27694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27695 }
27696 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27697 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27698 if (!SWIG_IsOK(res2)) {
27699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27700 }
27701 if (!argp2) {
27702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27703 }
27704 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27708 wxPyEndAllowThreads(__tstate);
27709 if (PyErr_Occurred()) SWIG_fail;
27710 }
27711 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27712 return resultobj;
27713 fail:
27714 return NULL;
27715 }
27716
27717
27718 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27719 PyObject *resultobj = 0;
27720 wxDateTime *arg1 = (wxDateTime *) 0 ;
27721 wxTimeSpan *arg2 = 0 ;
27722 wxDateTime result;
27723 void *argp1 = 0 ;
27724 int res1 = 0 ;
27725 void *argp2 = 0 ;
27726 int res2 = 0 ;
27727
27728 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27730 if (!SWIG_IsOK(res1)) {
27731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27732 }
27733 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27734 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27735 if (!SWIG_IsOK(res2)) {
27736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27737 }
27738 if (!argp2) {
27739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27740 }
27741 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27742 {
27743 PyThreadState* __tstate = wxPyBeginAllowThreads();
27744 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27745 wxPyEndAllowThreads(__tstate);
27746 if (PyErr_Occurred()) SWIG_fail;
27747 }
27748 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27749 return resultobj;
27750 fail:
27751 return NULL;
27752 }
27753
27754
27755 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27756 PyObject *resultobj = 0;
27757 wxDateTime *arg1 = (wxDateTime *) 0 ;
27758 wxDateSpan *arg2 = 0 ;
27759 wxDateTime result;
27760 void *argp1 = 0 ;
27761 int res1 = 0 ;
27762 void *argp2 = 0 ;
27763 int res2 = 0 ;
27764
27765 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27767 if (!SWIG_IsOK(res1)) {
27768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27769 }
27770 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27771 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27772 if (!SWIG_IsOK(res2)) {
27773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27774 }
27775 if (!argp2) {
27776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27777 }
27778 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27782 wxPyEndAllowThreads(__tstate);
27783 if (PyErr_Occurred()) SWIG_fail;
27784 }
27785 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27786 return resultobj;
27787 fail:
27788 return NULL;
27789 }
27790
27791
27792 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27793 int argc;
27794 PyObject *argv[3];
27795
27796 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27797 --argc;
27798 if (argc == 2) {
27799 int _v = 0;
27800 {
27801 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27802 _v = SWIG_CheckState(res);
27803 }
27804 if (!_v) goto check_1;
27805 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27806 }
27807 check_1:
27808
27809 if (argc == 2) {
27810 int _v = 0;
27811 {
27812 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27813 _v = SWIG_CheckState(res);
27814 }
27815 if (!_v) goto check_2;
27816 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27817 }
27818 check_2:
27819
27820 if (argc == 2) {
27821 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27822 }
27823
27824 fail:
27825 Py_INCREF(Py_NotImplemented);
27826 return Py_NotImplemented;
27827 }
27828
27829
27830 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27831 PyObject *resultobj = 0;
27832 wxDateTime *arg1 = (wxDateTime *) 0 ;
27833 wxDateTime *arg2 = (wxDateTime *) 0 ;
27834 bool result;
27835 void *argp1 = 0 ;
27836 int res1 = 0 ;
27837 void *argp2 = 0 ;
27838 int res2 = 0 ;
27839 PyObject * obj0 = 0 ;
27840 PyObject * obj1 = 0 ;
27841 char * kwnames[] = {
27842 (char *) "self",(char *) "other", NULL
27843 };
27844
27845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27847 if (!SWIG_IsOK(res1)) {
27848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27849 }
27850 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27851 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27852 if (!SWIG_IsOK(res2)) {
27853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27854 }
27855 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27856 {
27857 PyThreadState* __tstate = wxPyBeginAllowThreads();
27858 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27859 wxPyEndAllowThreads(__tstate);
27860 if (PyErr_Occurred()) SWIG_fail;
27861 }
27862 {
27863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27864 }
27865 return resultobj;
27866 fail:
27867 return NULL;
27868 }
27869
27870
27871 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27872 PyObject *resultobj = 0;
27873 wxDateTime *arg1 = (wxDateTime *) 0 ;
27874 wxDateTime *arg2 = (wxDateTime *) 0 ;
27875 bool result;
27876 void *argp1 = 0 ;
27877 int res1 = 0 ;
27878 void *argp2 = 0 ;
27879 int res2 = 0 ;
27880 PyObject * obj0 = 0 ;
27881 PyObject * obj1 = 0 ;
27882 char * kwnames[] = {
27883 (char *) "self",(char *) "other", NULL
27884 };
27885
27886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27888 if (!SWIG_IsOK(res1)) {
27889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27890 }
27891 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27893 if (!SWIG_IsOK(res2)) {
27894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27895 }
27896 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27897 {
27898 PyThreadState* __tstate = wxPyBeginAllowThreads();
27899 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 {
27904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27905 }
27906 return resultobj;
27907 fail:
27908 return NULL;
27909 }
27910
27911
27912 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27913 PyObject *resultobj = 0;
27914 wxDateTime *arg1 = (wxDateTime *) 0 ;
27915 wxDateTime *arg2 = (wxDateTime *) 0 ;
27916 bool result;
27917 void *argp1 = 0 ;
27918 int res1 = 0 ;
27919 void *argp2 = 0 ;
27920 int res2 = 0 ;
27921 PyObject * obj0 = 0 ;
27922 PyObject * obj1 = 0 ;
27923 char * kwnames[] = {
27924 (char *) "self",(char *) "other", NULL
27925 };
27926
27927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
27928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27929 if (!SWIG_IsOK(res1)) {
27930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27931 }
27932 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27933 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27934 if (!SWIG_IsOK(res2)) {
27935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27936 }
27937 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27938 {
27939 PyThreadState* __tstate = wxPyBeginAllowThreads();
27940 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
27941 wxPyEndAllowThreads(__tstate);
27942 if (PyErr_Occurred()) SWIG_fail;
27943 }
27944 {
27945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27946 }
27947 return resultobj;
27948 fail:
27949 return NULL;
27950 }
27951
27952
27953 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27954 PyObject *resultobj = 0;
27955 wxDateTime *arg1 = (wxDateTime *) 0 ;
27956 wxDateTime *arg2 = (wxDateTime *) 0 ;
27957 bool result;
27958 void *argp1 = 0 ;
27959 int res1 = 0 ;
27960 void *argp2 = 0 ;
27961 int res2 = 0 ;
27962 PyObject * obj0 = 0 ;
27963 PyObject * obj1 = 0 ;
27964 char * kwnames[] = {
27965 (char *) "self",(char *) "other", NULL
27966 };
27967
27968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
27969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27970 if (!SWIG_IsOK(res1)) {
27971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27972 }
27973 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27974 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27975 if (!SWIG_IsOK(res2)) {
27976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27977 }
27978 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
27982 wxPyEndAllowThreads(__tstate);
27983 if (PyErr_Occurred()) SWIG_fail;
27984 }
27985 {
27986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27987 }
27988 return resultobj;
27989 fail:
27990 return NULL;
27991 }
27992
27993
27994 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27995 PyObject *resultobj = 0;
27996 wxDateTime *arg1 = (wxDateTime *) 0 ;
27997 wxDateTime *arg2 = (wxDateTime *) 0 ;
27998 bool result;
27999 void *argp1 = 0 ;
28000 int res1 = 0 ;
28001 void *argp2 = 0 ;
28002 int res2 = 0 ;
28003 PyObject * obj0 = 0 ;
28004 PyObject * obj1 = 0 ;
28005 char * kwnames[] = {
28006 (char *) "self",(char *) "other", NULL
28007 };
28008
28009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28011 if (!SWIG_IsOK(res1)) {
28012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28013 }
28014 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28015 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28016 if (!SWIG_IsOK(res2)) {
28017 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28018 }
28019 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28020 {
28021 PyThreadState* __tstate = wxPyBeginAllowThreads();
28022 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28023 wxPyEndAllowThreads(__tstate);
28024 if (PyErr_Occurred()) SWIG_fail;
28025 }
28026 {
28027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28028 }
28029 return resultobj;
28030 fail:
28031 return NULL;
28032 }
28033
28034
28035 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28036 PyObject *resultobj = 0;
28037 wxDateTime *arg1 = (wxDateTime *) 0 ;
28038 wxDateTime *arg2 = (wxDateTime *) 0 ;
28039 bool result;
28040 void *argp1 = 0 ;
28041 int res1 = 0 ;
28042 void *argp2 = 0 ;
28043 int res2 = 0 ;
28044 PyObject * obj0 = 0 ;
28045 PyObject * obj1 = 0 ;
28046 char * kwnames[] = {
28047 (char *) "self",(char *) "other", NULL
28048 };
28049
28050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28052 if (!SWIG_IsOK(res1)) {
28053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28054 }
28055 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28056 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28057 if (!SWIG_IsOK(res2)) {
28058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28059 }
28060 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28064 wxPyEndAllowThreads(__tstate);
28065 if (PyErr_Occurred()) SWIG_fail;
28066 }
28067 {
28068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28069 }
28070 return resultobj;
28071 fail:
28072 return NULL;
28073 }
28074
28075
28076 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28077 PyObject *resultobj = 0;
28078 wxDateTime *arg1 = (wxDateTime *) 0 ;
28079 wxString *arg2 = 0 ;
28080 int result;
28081 void *argp1 = 0 ;
28082 int res1 = 0 ;
28083 bool temp2 = false ;
28084 PyObject * obj0 = 0 ;
28085 PyObject * obj1 = 0 ;
28086 char * kwnames[] = {
28087 (char *) "self",(char *) "date", NULL
28088 };
28089
28090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28092 if (!SWIG_IsOK(res1)) {
28093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28094 }
28095 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28096 {
28097 arg2 = wxString_in_helper(obj1);
28098 if (arg2 == NULL) SWIG_fail;
28099 temp2 = true;
28100 }
28101 {
28102 PyThreadState* __tstate = wxPyBeginAllowThreads();
28103 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28104 wxPyEndAllowThreads(__tstate);
28105 if (PyErr_Occurred()) SWIG_fail;
28106 }
28107 resultobj = SWIG_From_int(static_cast< int >(result));
28108 {
28109 if (temp2)
28110 delete arg2;
28111 }
28112 return resultobj;
28113 fail:
28114 {
28115 if (temp2)
28116 delete arg2;
28117 }
28118 return NULL;
28119 }
28120
28121
28122 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28123 PyObject *resultobj = 0;
28124 wxDateTime *arg1 = (wxDateTime *) 0 ;
28125 wxString *arg2 = 0 ;
28126 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28127 wxString *arg3 = (wxString *) &arg3_defvalue ;
28128 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28129 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28130 int result;
28131 void *argp1 = 0 ;
28132 int res1 = 0 ;
28133 bool temp2 = false ;
28134 bool temp3 = false ;
28135 void *argp4 = 0 ;
28136 int res4 = 0 ;
28137 PyObject * obj0 = 0 ;
28138 PyObject * obj1 = 0 ;
28139 PyObject * obj2 = 0 ;
28140 PyObject * obj3 = 0 ;
28141 char * kwnames[] = {
28142 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28143 };
28144
28145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28147 if (!SWIG_IsOK(res1)) {
28148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28149 }
28150 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28151 {
28152 arg2 = wxString_in_helper(obj1);
28153 if (arg2 == NULL) SWIG_fail;
28154 temp2 = true;
28155 }
28156 if (obj2) {
28157 {
28158 arg3 = wxString_in_helper(obj2);
28159 if (arg3 == NULL) SWIG_fail;
28160 temp3 = true;
28161 }
28162 }
28163 if (obj3) {
28164 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28165 if (!SWIG_IsOK(res4)) {
28166 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28167 }
28168 if (!argp4) {
28169 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28170 }
28171 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28172 }
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28176 wxPyEndAllowThreads(__tstate);
28177 if (PyErr_Occurred()) SWIG_fail;
28178 }
28179 resultobj = SWIG_From_int(static_cast< int >(result));
28180 {
28181 if (temp2)
28182 delete arg2;
28183 }
28184 {
28185 if (temp3)
28186 delete arg3;
28187 }
28188 return resultobj;
28189 fail:
28190 {
28191 if (temp2)
28192 delete arg2;
28193 }
28194 {
28195 if (temp3)
28196 delete arg3;
28197 }
28198 return NULL;
28199 }
28200
28201
28202 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28203 PyObject *resultobj = 0;
28204 wxDateTime *arg1 = (wxDateTime *) 0 ;
28205 wxString *arg2 = 0 ;
28206 int result;
28207 void *argp1 = 0 ;
28208 int res1 = 0 ;
28209 bool temp2 = false ;
28210 PyObject * obj0 = 0 ;
28211 PyObject * obj1 = 0 ;
28212 char * kwnames[] = {
28213 (char *) "self",(char *) "datetime", NULL
28214 };
28215
28216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28218 if (!SWIG_IsOK(res1)) {
28219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28220 }
28221 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28222 {
28223 arg2 = wxString_in_helper(obj1);
28224 if (arg2 == NULL) SWIG_fail;
28225 temp2 = true;
28226 }
28227 {
28228 PyThreadState* __tstate = wxPyBeginAllowThreads();
28229 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28230 wxPyEndAllowThreads(__tstate);
28231 if (PyErr_Occurred()) SWIG_fail;
28232 }
28233 resultobj = SWIG_From_int(static_cast< int >(result));
28234 {
28235 if (temp2)
28236 delete arg2;
28237 }
28238 return resultobj;
28239 fail:
28240 {
28241 if (temp2)
28242 delete arg2;
28243 }
28244 return NULL;
28245 }
28246
28247
28248 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28249 PyObject *resultobj = 0;
28250 wxDateTime *arg1 = (wxDateTime *) 0 ;
28251 wxString *arg2 = 0 ;
28252 int result;
28253 void *argp1 = 0 ;
28254 int res1 = 0 ;
28255 bool temp2 = false ;
28256 PyObject * obj0 = 0 ;
28257 PyObject * obj1 = 0 ;
28258 char * kwnames[] = {
28259 (char *) "self",(char *) "date", NULL
28260 };
28261
28262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28264 if (!SWIG_IsOK(res1)) {
28265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28266 }
28267 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28268 {
28269 arg2 = wxString_in_helper(obj1);
28270 if (arg2 == NULL) SWIG_fail;
28271 temp2 = true;
28272 }
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28276 wxPyEndAllowThreads(__tstate);
28277 if (PyErr_Occurred()) SWIG_fail;
28278 }
28279 resultobj = SWIG_From_int(static_cast< int >(result));
28280 {
28281 if (temp2)
28282 delete arg2;
28283 }
28284 return resultobj;
28285 fail:
28286 {
28287 if (temp2)
28288 delete arg2;
28289 }
28290 return NULL;
28291 }
28292
28293
28294 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28295 PyObject *resultobj = 0;
28296 wxDateTime *arg1 = (wxDateTime *) 0 ;
28297 wxString *arg2 = 0 ;
28298 int result;
28299 void *argp1 = 0 ;
28300 int res1 = 0 ;
28301 bool temp2 = false ;
28302 PyObject * obj0 = 0 ;
28303 PyObject * obj1 = 0 ;
28304 char * kwnames[] = {
28305 (char *) "self",(char *) "time", NULL
28306 };
28307
28308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28310 if (!SWIG_IsOK(res1)) {
28311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28312 }
28313 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28314 {
28315 arg2 = wxString_in_helper(obj1);
28316 if (arg2 == NULL) SWIG_fail;
28317 temp2 = true;
28318 }
28319 {
28320 PyThreadState* __tstate = wxPyBeginAllowThreads();
28321 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28322 wxPyEndAllowThreads(__tstate);
28323 if (PyErr_Occurred()) SWIG_fail;
28324 }
28325 resultobj = SWIG_From_int(static_cast< int >(result));
28326 {
28327 if (temp2)
28328 delete arg2;
28329 }
28330 return resultobj;
28331 fail:
28332 {
28333 if (temp2)
28334 delete arg2;
28335 }
28336 return NULL;
28337 }
28338
28339
28340 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28341 PyObject *resultobj = 0;
28342 wxDateTime *arg1 = (wxDateTime *) 0 ;
28343 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28344 wxString *arg2 = (wxString *) &arg2_defvalue ;
28345 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28346 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28347 wxString result;
28348 void *argp1 = 0 ;
28349 int res1 = 0 ;
28350 bool temp2 = false ;
28351 bool temp3 = false ;
28352 PyObject * obj0 = 0 ;
28353 PyObject * obj1 = 0 ;
28354 PyObject * obj2 = 0 ;
28355 char * kwnames[] = {
28356 (char *) "self",(char *) "format",(char *) "tz", NULL
28357 };
28358
28359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28361 if (!SWIG_IsOK(res1)) {
28362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28363 }
28364 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28365 if (obj1) {
28366 {
28367 arg2 = wxString_in_helper(obj1);
28368 if (arg2 == NULL) SWIG_fail;
28369 temp2 = true;
28370 }
28371 }
28372 if (obj2) {
28373 {
28374 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28375 temp3 = true;
28376 }
28377 }
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28381 wxPyEndAllowThreads(__tstate);
28382 if (PyErr_Occurred()) SWIG_fail;
28383 }
28384 {
28385 #if wxUSE_UNICODE
28386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28387 #else
28388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28389 #endif
28390 }
28391 {
28392 if (temp2)
28393 delete arg2;
28394 }
28395 {
28396 if (temp3) delete arg3;
28397 }
28398 return resultobj;
28399 fail:
28400 {
28401 if (temp2)
28402 delete arg2;
28403 }
28404 {
28405 if (temp3) delete arg3;
28406 }
28407 return NULL;
28408 }
28409
28410
28411 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28412 PyObject *resultobj = 0;
28413 wxDateTime *arg1 = (wxDateTime *) 0 ;
28414 wxString result;
28415 void *argp1 = 0 ;
28416 int res1 = 0 ;
28417 PyObject *swig_obj[1] ;
28418
28419 if (!args) SWIG_fail;
28420 swig_obj[0] = args;
28421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28422 if (!SWIG_IsOK(res1)) {
28423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28424 }
28425 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28426 {
28427 PyThreadState* __tstate = wxPyBeginAllowThreads();
28428 result = ((wxDateTime const *)arg1)->FormatDate();
28429 wxPyEndAllowThreads(__tstate);
28430 if (PyErr_Occurred()) SWIG_fail;
28431 }
28432 {
28433 #if wxUSE_UNICODE
28434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28435 #else
28436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28437 #endif
28438 }
28439 return resultobj;
28440 fail:
28441 return NULL;
28442 }
28443
28444
28445 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28446 PyObject *resultobj = 0;
28447 wxDateTime *arg1 = (wxDateTime *) 0 ;
28448 wxString result;
28449 void *argp1 = 0 ;
28450 int res1 = 0 ;
28451 PyObject *swig_obj[1] ;
28452
28453 if (!args) SWIG_fail;
28454 swig_obj[0] = args;
28455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28456 if (!SWIG_IsOK(res1)) {
28457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28458 }
28459 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 result = ((wxDateTime const *)arg1)->FormatTime();
28463 wxPyEndAllowThreads(__tstate);
28464 if (PyErr_Occurred()) SWIG_fail;
28465 }
28466 {
28467 #if wxUSE_UNICODE
28468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28469 #else
28470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28471 #endif
28472 }
28473 return resultobj;
28474 fail:
28475 return NULL;
28476 }
28477
28478
28479 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28480 PyObject *resultobj = 0;
28481 wxDateTime *arg1 = (wxDateTime *) 0 ;
28482 wxString result;
28483 void *argp1 = 0 ;
28484 int res1 = 0 ;
28485 PyObject *swig_obj[1] ;
28486
28487 if (!args) SWIG_fail;
28488 swig_obj[0] = args;
28489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28490 if (!SWIG_IsOK(res1)) {
28491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28492 }
28493 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28494 {
28495 PyThreadState* __tstate = wxPyBeginAllowThreads();
28496 result = ((wxDateTime const *)arg1)->FormatISODate();
28497 wxPyEndAllowThreads(__tstate);
28498 if (PyErr_Occurred()) SWIG_fail;
28499 }
28500 {
28501 #if wxUSE_UNICODE
28502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28503 #else
28504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28505 #endif
28506 }
28507 return resultobj;
28508 fail:
28509 return NULL;
28510 }
28511
28512
28513 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28514 PyObject *resultobj = 0;
28515 wxDateTime *arg1 = (wxDateTime *) 0 ;
28516 wxString result;
28517 void *argp1 = 0 ;
28518 int res1 = 0 ;
28519 PyObject *swig_obj[1] ;
28520
28521 if (!args) SWIG_fail;
28522 swig_obj[0] = args;
28523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28524 if (!SWIG_IsOK(res1)) {
28525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28526 }
28527 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = ((wxDateTime const *)arg1)->FormatISOTime();
28531 wxPyEndAllowThreads(__tstate);
28532 if (PyErr_Occurred()) SWIG_fail;
28533 }
28534 {
28535 #if wxUSE_UNICODE
28536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28537 #else
28538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28539 #endif
28540 }
28541 return resultobj;
28542 fail:
28543 return NULL;
28544 }
28545
28546
28547 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28548 PyObject *obj;
28549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28550 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28551 return SWIG_Py_Void();
28552 }
28553
28554 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28555 return SWIG_Python_InitShadowInstance(args);
28556 }
28557
28558 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28559 PyObject *resultobj = 0;
28560 long arg1 ;
28561 wxTimeSpan result;
28562 long val1 ;
28563 int ecode1 = 0 ;
28564 PyObject * obj0 = 0 ;
28565 char * kwnames[] = {
28566 (char *) "ms", NULL
28567 };
28568
28569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28570 ecode1 = SWIG_AsVal_long(obj0, &val1);
28571 if (!SWIG_IsOK(ecode1)) {
28572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28573 }
28574 arg1 = static_cast< long >(val1);
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = wxTimeSpan::Milliseconds(arg1);
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28589 PyObject *resultobj = 0;
28590 wxTimeSpan result;
28591
28592 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28593 {
28594 PyThreadState* __tstate = wxPyBeginAllowThreads();
28595 result = wxTimeSpan::Millisecond();
28596 wxPyEndAllowThreads(__tstate);
28597 if (PyErr_Occurred()) SWIG_fail;
28598 }
28599 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28600 return resultobj;
28601 fail:
28602 return NULL;
28603 }
28604
28605
28606 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28607 PyObject *resultobj = 0;
28608 long arg1 ;
28609 wxTimeSpan result;
28610 long val1 ;
28611 int ecode1 = 0 ;
28612 PyObject * obj0 = 0 ;
28613 char * kwnames[] = {
28614 (char *) "sec", NULL
28615 };
28616
28617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28618 ecode1 = SWIG_AsVal_long(obj0, &val1);
28619 if (!SWIG_IsOK(ecode1)) {
28620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28621 }
28622 arg1 = static_cast< long >(val1);
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 result = wxTimeSpan::Seconds(arg1);
28626 wxPyEndAllowThreads(__tstate);
28627 if (PyErr_Occurred()) SWIG_fail;
28628 }
28629 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28630 return resultobj;
28631 fail:
28632 return NULL;
28633 }
28634
28635
28636 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28637 PyObject *resultobj = 0;
28638 wxTimeSpan result;
28639
28640 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28641 {
28642 PyThreadState* __tstate = wxPyBeginAllowThreads();
28643 result = wxTimeSpan::Second();
28644 wxPyEndAllowThreads(__tstate);
28645 if (PyErr_Occurred()) SWIG_fail;
28646 }
28647 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28648 return resultobj;
28649 fail:
28650 return NULL;
28651 }
28652
28653
28654 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28655 PyObject *resultobj = 0;
28656 long arg1 ;
28657 wxTimeSpan result;
28658 long val1 ;
28659 int ecode1 = 0 ;
28660 PyObject * obj0 = 0 ;
28661 char * kwnames[] = {
28662 (char *) "min", NULL
28663 };
28664
28665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28666 ecode1 = SWIG_AsVal_long(obj0, &val1);
28667 if (!SWIG_IsOK(ecode1)) {
28668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28669 }
28670 arg1 = static_cast< long >(val1);
28671 {
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 result = wxTimeSpan::Minutes(arg1);
28674 wxPyEndAllowThreads(__tstate);
28675 if (PyErr_Occurred()) SWIG_fail;
28676 }
28677 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28685 PyObject *resultobj = 0;
28686 wxTimeSpan result;
28687
28688 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28689 {
28690 PyThreadState* __tstate = wxPyBeginAllowThreads();
28691 result = wxTimeSpan::Minute();
28692 wxPyEndAllowThreads(__tstate);
28693 if (PyErr_Occurred()) SWIG_fail;
28694 }
28695 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28696 return resultobj;
28697 fail:
28698 return NULL;
28699 }
28700
28701
28702 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28703 PyObject *resultobj = 0;
28704 long arg1 ;
28705 wxTimeSpan result;
28706 long val1 ;
28707 int ecode1 = 0 ;
28708 PyObject * obj0 = 0 ;
28709 char * kwnames[] = {
28710 (char *) "hours", NULL
28711 };
28712
28713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28714 ecode1 = SWIG_AsVal_long(obj0, &val1);
28715 if (!SWIG_IsOK(ecode1)) {
28716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28717 }
28718 arg1 = static_cast< long >(val1);
28719 {
28720 PyThreadState* __tstate = wxPyBeginAllowThreads();
28721 result = wxTimeSpan::Hours(arg1);
28722 wxPyEndAllowThreads(__tstate);
28723 if (PyErr_Occurred()) SWIG_fail;
28724 }
28725 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28726 return resultobj;
28727 fail:
28728 return NULL;
28729 }
28730
28731
28732 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28733 PyObject *resultobj = 0;
28734 wxTimeSpan result;
28735
28736 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28737 {
28738 PyThreadState* __tstate = wxPyBeginAllowThreads();
28739 result = wxTimeSpan::Hour();
28740 wxPyEndAllowThreads(__tstate);
28741 if (PyErr_Occurred()) SWIG_fail;
28742 }
28743 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28744 return resultobj;
28745 fail:
28746 return NULL;
28747 }
28748
28749
28750 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28751 PyObject *resultobj = 0;
28752 long arg1 ;
28753 wxTimeSpan result;
28754 long val1 ;
28755 int ecode1 = 0 ;
28756 PyObject * obj0 = 0 ;
28757 char * kwnames[] = {
28758 (char *) "days", NULL
28759 };
28760
28761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28762 ecode1 = SWIG_AsVal_long(obj0, &val1);
28763 if (!SWIG_IsOK(ecode1)) {
28764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28765 }
28766 arg1 = static_cast< long >(val1);
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 result = wxTimeSpan::Days(arg1);
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28781 PyObject *resultobj = 0;
28782 wxTimeSpan result;
28783
28784 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28785 {
28786 PyThreadState* __tstate = wxPyBeginAllowThreads();
28787 result = wxTimeSpan::Day();
28788 wxPyEndAllowThreads(__tstate);
28789 if (PyErr_Occurred()) SWIG_fail;
28790 }
28791 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28792 return resultobj;
28793 fail:
28794 return NULL;
28795 }
28796
28797
28798 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28799 PyObject *resultobj = 0;
28800 long arg1 ;
28801 wxTimeSpan result;
28802 long val1 ;
28803 int ecode1 = 0 ;
28804 PyObject * obj0 = 0 ;
28805 char * kwnames[] = {
28806 (char *) "days", NULL
28807 };
28808
28809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28810 ecode1 = SWIG_AsVal_long(obj0, &val1);
28811 if (!SWIG_IsOK(ecode1)) {
28812 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28813 }
28814 arg1 = static_cast< long >(val1);
28815 {
28816 PyThreadState* __tstate = wxPyBeginAllowThreads();
28817 result = wxTimeSpan::Weeks(arg1);
28818 wxPyEndAllowThreads(__tstate);
28819 if (PyErr_Occurred()) SWIG_fail;
28820 }
28821 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28822 return resultobj;
28823 fail:
28824 return NULL;
28825 }
28826
28827
28828 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28829 PyObject *resultobj = 0;
28830 wxTimeSpan result;
28831
28832 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28833 {
28834 PyThreadState* __tstate = wxPyBeginAllowThreads();
28835 result = wxTimeSpan::Week();
28836 wxPyEndAllowThreads(__tstate);
28837 if (PyErr_Occurred()) SWIG_fail;
28838 }
28839 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28840 return resultobj;
28841 fail:
28842 return NULL;
28843 }
28844
28845
28846 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28847 PyObject *resultobj = 0;
28848 long arg1 = (long) 0 ;
28849 long arg2 = (long) 0 ;
28850 long arg3 = (long) 0 ;
28851 long arg4 = (long) 0 ;
28852 wxTimeSpan *result = 0 ;
28853 long val1 ;
28854 int ecode1 = 0 ;
28855 long val2 ;
28856 int ecode2 = 0 ;
28857 long val3 ;
28858 int ecode3 = 0 ;
28859 long val4 ;
28860 int ecode4 = 0 ;
28861 PyObject * obj0 = 0 ;
28862 PyObject * obj1 = 0 ;
28863 PyObject * obj2 = 0 ;
28864 PyObject * obj3 = 0 ;
28865 char * kwnames[] = {
28866 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28867 };
28868
28869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28870 if (obj0) {
28871 ecode1 = SWIG_AsVal_long(obj0, &val1);
28872 if (!SWIG_IsOK(ecode1)) {
28873 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28874 }
28875 arg1 = static_cast< long >(val1);
28876 }
28877 if (obj1) {
28878 ecode2 = SWIG_AsVal_long(obj1, &val2);
28879 if (!SWIG_IsOK(ecode2)) {
28880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28881 }
28882 arg2 = static_cast< long >(val2);
28883 }
28884 if (obj2) {
28885 ecode3 = SWIG_AsVal_long(obj2, &val3);
28886 if (!SWIG_IsOK(ecode3)) {
28887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28888 }
28889 arg3 = static_cast< long >(val3);
28890 }
28891 if (obj3) {
28892 ecode4 = SWIG_AsVal_long(obj3, &val4);
28893 if (!SWIG_IsOK(ecode4)) {
28894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28895 }
28896 arg4 = static_cast< long >(val4);
28897 }
28898 {
28899 PyThreadState* __tstate = wxPyBeginAllowThreads();
28900 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28912 PyObject *resultobj = 0;
28913 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28914 void *argp1 = 0 ;
28915 int res1 = 0 ;
28916 PyObject *swig_obj[1] ;
28917
28918 if (!args) SWIG_fail;
28919 swig_obj[0] = args;
28920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28921 if (!SWIG_IsOK(res1)) {
28922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28923 }
28924 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28925 {
28926 PyThreadState* __tstate = wxPyBeginAllowThreads();
28927 delete arg1;
28928
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 resultobj = SWIG_Py_Void();
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28940 PyObject *resultobj = 0;
28941 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28942 wxTimeSpan *arg2 = 0 ;
28943 wxTimeSpan *result = 0 ;
28944 void *argp1 = 0 ;
28945 int res1 = 0 ;
28946 void *argp2 = 0 ;
28947 int res2 = 0 ;
28948 PyObject * obj0 = 0 ;
28949 PyObject * obj1 = 0 ;
28950 char * kwnames[] = {
28951 (char *) "self",(char *) "diff", NULL
28952 };
28953
28954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
28955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28956 if (!SWIG_IsOK(res1)) {
28957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28958 }
28959 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28960 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28961 if (!SWIG_IsOK(res2)) {
28962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28963 }
28964 if (!argp2) {
28965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28966 }
28967 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28968 {
28969 PyThreadState* __tstate = wxPyBeginAllowThreads();
28970 {
28971 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
28972 result = (wxTimeSpan *) &_result_ref;
28973 }
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28978 return resultobj;
28979 fail:
28980 return NULL;
28981 }
28982
28983
28984 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28985 PyObject *resultobj = 0;
28986 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28987 wxTimeSpan *arg2 = 0 ;
28988 wxTimeSpan *result = 0 ;
28989 void *argp1 = 0 ;
28990 int res1 = 0 ;
28991 void *argp2 = 0 ;
28992 int res2 = 0 ;
28993 PyObject * obj0 = 0 ;
28994 PyObject * obj1 = 0 ;
28995 char * kwnames[] = {
28996 (char *) "self",(char *) "diff", NULL
28997 };
28998
28999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29001 if (!SWIG_IsOK(res1)) {
29002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29003 }
29004 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29006 if (!SWIG_IsOK(res2)) {
29007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29008 }
29009 if (!argp2) {
29010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29011 }
29012 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29013 {
29014 PyThreadState* __tstate = wxPyBeginAllowThreads();
29015 {
29016 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29017 result = (wxTimeSpan *) &_result_ref;
29018 }
29019 wxPyEndAllowThreads(__tstate);
29020 if (PyErr_Occurred()) SWIG_fail;
29021 }
29022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29023 return resultobj;
29024 fail:
29025 return NULL;
29026 }
29027
29028
29029 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29030 PyObject *resultobj = 0;
29031 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29032 int arg2 ;
29033 wxTimeSpan *result = 0 ;
29034 void *argp1 = 0 ;
29035 int res1 = 0 ;
29036 int val2 ;
29037 int ecode2 = 0 ;
29038 PyObject * obj0 = 0 ;
29039 PyObject * obj1 = 0 ;
29040 char * kwnames[] = {
29041 (char *) "self",(char *) "n", NULL
29042 };
29043
29044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29046 if (!SWIG_IsOK(res1)) {
29047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29048 }
29049 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29050 ecode2 = SWIG_AsVal_int(obj1, &val2);
29051 if (!SWIG_IsOK(ecode2)) {
29052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29053 }
29054 arg2 = static_cast< int >(val2);
29055 {
29056 PyThreadState* __tstate = wxPyBeginAllowThreads();
29057 {
29058 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29059 result = (wxTimeSpan *) &_result_ref;
29060 }
29061 wxPyEndAllowThreads(__tstate);
29062 if (PyErr_Occurred()) SWIG_fail;
29063 }
29064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29065 return resultobj;
29066 fail:
29067 return NULL;
29068 }
29069
29070
29071 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29072 PyObject *resultobj = 0;
29073 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29074 wxTimeSpan *result = 0 ;
29075 void *argp1 = 0 ;
29076 int res1 = 0 ;
29077 PyObject *swig_obj[1] ;
29078
29079 if (!args) SWIG_fail;
29080 swig_obj[0] = args;
29081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29082 if (!SWIG_IsOK(res1)) {
29083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29084 }
29085 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29086 {
29087 PyThreadState* __tstate = wxPyBeginAllowThreads();
29088 {
29089 wxTimeSpan &_result_ref = (arg1)->Neg();
29090 result = (wxTimeSpan *) &_result_ref;
29091 }
29092 wxPyEndAllowThreads(__tstate);
29093 if (PyErr_Occurred()) SWIG_fail;
29094 }
29095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29096 return resultobj;
29097 fail:
29098 return NULL;
29099 }
29100
29101
29102 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29103 PyObject *resultobj = 0;
29104 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29105 wxTimeSpan result;
29106 void *argp1 = 0 ;
29107 int res1 = 0 ;
29108 PyObject *swig_obj[1] ;
29109
29110 if (!args) SWIG_fail;
29111 swig_obj[0] = args;
29112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29113 if (!SWIG_IsOK(res1)) {
29114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29115 }
29116 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29117 {
29118 PyThreadState* __tstate = wxPyBeginAllowThreads();
29119 result = ((wxTimeSpan const *)arg1)->Abs();
29120 wxPyEndAllowThreads(__tstate);
29121 if (PyErr_Occurred()) SWIG_fail;
29122 }
29123 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29124 return resultobj;
29125 fail:
29126 return NULL;
29127 }
29128
29129
29130 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29131 PyObject *resultobj = 0;
29132 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29133 wxTimeSpan *arg2 = 0 ;
29134 wxTimeSpan *result = 0 ;
29135 void *argp1 = 0 ;
29136 int res1 = 0 ;
29137 void *argp2 = 0 ;
29138 int res2 = 0 ;
29139 PyObject * obj0 = 0 ;
29140 PyObject * obj1 = 0 ;
29141 char * kwnames[] = {
29142 (char *) "self",(char *) "diff", NULL
29143 };
29144
29145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29147 if (!SWIG_IsOK(res1)) {
29148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29149 }
29150 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29151 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29152 if (!SWIG_IsOK(res2)) {
29153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29154 }
29155 if (!argp2) {
29156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29157 }
29158 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29159 {
29160 PyThreadState* __tstate = wxPyBeginAllowThreads();
29161 {
29162 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29163 result = (wxTimeSpan *) &_result_ref;
29164 }
29165 wxPyEndAllowThreads(__tstate);
29166 if (PyErr_Occurred()) SWIG_fail;
29167 }
29168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29169 return resultobj;
29170 fail:
29171 return NULL;
29172 }
29173
29174
29175 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29176 PyObject *resultobj = 0;
29177 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29178 wxTimeSpan *arg2 = 0 ;
29179 wxTimeSpan *result = 0 ;
29180 void *argp1 = 0 ;
29181 int res1 = 0 ;
29182 void *argp2 = 0 ;
29183 int res2 = 0 ;
29184 PyObject * obj0 = 0 ;
29185 PyObject * obj1 = 0 ;
29186 char * kwnames[] = {
29187 (char *) "self",(char *) "diff", NULL
29188 };
29189
29190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29192 if (!SWIG_IsOK(res1)) {
29193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29194 }
29195 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29196 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29197 if (!SWIG_IsOK(res2)) {
29198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29199 }
29200 if (!argp2) {
29201 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29202 }
29203 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 {
29207 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29208 result = (wxTimeSpan *) &_result_ref;
29209 }
29210 wxPyEndAllowThreads(__tstate);
29211 if (PyErr_Occurred()) SWIG_fail;
29212 }
29213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29214 return resultobj;
29215 fail:
29216 return NULL;
29217 }
29218
29219
29220 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29221 PyObject *resultobj = 0;
29222 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29223 int arg2 ;
29224 wxTimeSpan *result = 0 ;
29225 void *argp1 = 0 ;
29226 int res1 = 0 ;
29227 int val2 ;
29228 int ecode2 = 0 ;
29229 PyObject * obj0 = 0 ;
29230 PyObject * obj1 = 0 ;
29231 char * kwnames[] = {
29232 (char *) "self",(char *) "n", NULL
29233 };
29234
29235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29237 if (!SWIG_IsOK(res1)) {
29238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29239 }
29240 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29241 ecode2 = SWIG_AsVal_int(obj1, &val2);
29242 if (!SWIG_IsOK(ecode2)) {
29243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29244 }
29245 arg2 = static_cast< int >(val2);
29246 {
29247 PyThreadState* __tstate = wxPyBeginAllowThreads();
29248 {
29249 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29250 result = (wxTimeSpan *) &_result_ref;
29251 }
29252 wxPyEndAllowThreads(__tstate);
29253 if (PyErr_Occurred()) SWIG_fail;
29254 }
29255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29263 PyObject *resultobj = 0;
29264 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29265 wxTimeSpan *result = 0 ;
29266 void *argp1 = 0 ;
29267 int res1 = 0 ;
29268 PyObject *swig_obj[1] ;
29269
29270 if (!args) SWIG_fail;
29271 swig_obj[0] = args;
29272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29273 if (!SWIG_IsOK(res1)) {
29274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29275 }
29276 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29277 {
29278 PyThreadState* __tstate = wxPyBeginAllowThreads();
29279 {
29280 wxTimeSpan &_result_ref = (arg1)->operator -();
29281 result = (wxTimeSpan *) &_result_ref;
29282 }
29283 wxPyEndAllowThreads(__tstate);
29284 if (PyErr_Occurred()) SWIG_fail;
29285 }
29286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29287 return resultobj;
29288 fail:
29289 return NULL;
29290 }
29291
29292
29293 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29294 PyObject *resultobj = 0;
29295 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29296 wxTimeSpan *arg2 = 0 ;
29297 wxTimeSpan result;
29298 void *argp1 = 0 ;
29299 int res1 = 0 ;
29300 void *argp2 = 0 ;
29301 int res2 = 0 ;
29302 PyObject * obj0 = 0 ;
29303 PyObject * obj1 = 0 ;
29304 char * kwnames[] = {
29305 (char *) "self",(char *) "other", NULL
29306 };
29307
29308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29310 if (!SWIG_IsOK(res1)) {
29311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29312 }
29313 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29314 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29315 if (!SWIG_IsOK(res2)) {
29316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29317 }
29318 if (!argp2) {
29319 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29320 }
29321 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29322 {
29323 PyThreadState* __tstate = wxPyBeginAllowThreads();
29324 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29325 wxPyEndAllowThreads(__tstate);
29326 if (PyErr_Occurred()) SWIG_fail;
29327 }
29328 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29329 return resultobj;
29330 fail:
29331 return NULL;
29332 }
29333
29334
29335 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29336 PyObject *resultobj = 0;
29337 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29338 wxTimeSpan *arg2 = 0 ;
29339 wxTimeSpan result;
29340 void *argp1 = 0 ;
29341 int res1 = 0 ;
29342 void *argp2 = 0 ;
29343 int res2 = 0 ;
29344 PyObject * obj0 = 0 ;
29345 PyObject * obj1 = 0 ;
29346 char * kwnames[] = {
29347 (char *) "self",(char *) "other", NULL
29348 };
29349
29350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29352 if (!SWIG_IsOK(res1)) {
29353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29354 }
29355 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29356 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29357 if (!SWIG_IsOK(res2)) {
29358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29359 }
29360 if (!argp2) {
29361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29362 }
29363 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29364 {
29365 PyThreadState* __tstate = wxPyBeginAllowThreads();
29366 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29367 wxPyEndAllowThreads(__tstate);
29368 if (PyErr_Occurred()) SWIG_fail;
29369 }
29370 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29378 PyObject *resultobj = 0;
29379 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29380 int arg2 ;
29381 wxTimeSpan result;
29382 void *argp1 = 0 ;
29383 int res1 = 0 ;
29384 int val2 ;
29385 int ecode2 = 0 ;
29386 PyObject * obj0 = 0 ;
29387 PyObject * obj1 = 0 ;
29388 char * kwnames[] = {
29389 (char *) "self",(char *) "n", NULL
29390 };
29391
29392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29394 if (!SWIG_IsOK(res1)) {
29395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29396 }
29397 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29398 ecode2 = SWIG_AsVal_int(obj1, &val2);
29399 if (!SWIG_IsOK(ecode2)) {
29400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29401 }
29402 arg2 = static_cast< int >(val2);
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 result = wxTimeSpan___mul__(arg1,arg2);
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29417 PyObject *resultobj = 0;
29418 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29419 int arg2 ;
29420 wxTimeSpan result;
29421 void *argp1 = 0 ;
29422 int res1 = 0 ;
29423 int val2 ;
29424 int ecode2 = 0 ;
29425 PyObject * obj0 = 0 ;
29426 PyObject * obj1 = 0 ;
29427 char * kwnames[] = {
29428 (char *) "self",(char *) "n", NULL
29429 };
29430
29431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29433 if (!SWIG_IsOK(res1)) {
29434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29435 }
29436 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29437 ecode2 = SWIG_AsVal_int(obj1, &val2);
29438 if (!SWIG_IsOK(ecode2)) {
29439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29440 }
29441 arg2 = static_cast< int >(val2);
29442 {
29443 PyThreadState* __tstate = wxPyBeginAllowThreads();
29444 result = wxTimeSpan___rmul__(arg1,arg2);
29445 wxPyEndAllowThreads(__tstate);
29446 if (PyErr_Occurred()) SWIG_fail;
29447 }
29448 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29449 return resultobj;
29450 fail:
29451 return NULL;
29452 }
29453
29454
29455 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29456 PyObject *resultobj = 0;
29457 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29458 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29459 bool result;
29460 void *argp1 = 0 ;
29461 int res1 = 0 ;
29462 void *argp2 = 0 ;
29463 int res2 = 0 ;
29464 PyObject * obj0 = 0 ;
29465 PyObject * obj1 = 0 ;
29466 char * kwnames[] = {
29467 (char *) "self",(char *) "other", NULL
29468 };
29469
29470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29472 if (!SWIG_IsOK(res1)) {
29473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29474 }
29475 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29476 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29477 if (!SWIG_IsOK(res2)) {
29478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29479 }
29480 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29481 {
29482 PyThreadState* __tstate = wxPyBeginAllowThreads();
29483 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29484 wxPyEndAllowThreads(__tstate);
29485 if (PyErr_Occurred()) SWIG_fail;
29486 }
29487 {
29488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29489 }
29490 return resultobj;
29491 fail:
29492 return NULL;
29493 }
29494
29495
29496 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29497 PyObject *resultobj = 0;
29498 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29499 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29500 bool result;
29501 void *argp1 = 0 ;
29502 int res1 = 0 ;
29503 void *argp2 = 0 ;
29504 int res2 = 0 ;
29505 PyObject * obj0 = 0 ;
29506 PyObject * obj1 = 0 ;
29507 char * kwnames[] = {
29508 (char *) "self",(char *) "other", NULL
29509 };
29510
29511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29513 if (!SWIG_IsOK(res1)) {
29514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29515 }
29516 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29518 if (!SWIG_IsOK(res2)) {
29519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29520 }
29521 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29522 {
29523 PyThreadState* __tstate = wxPyBeginAllowThreads();
29524 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29525 wxPyEndAllowThreads(__tstate);
29526 if (PyErr_Occurred()) SWIG_fail;
29527 }
29528 {
29529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29530 }
29531 return resultobj;
29532 fail:
29533 return NULL;
29534 }
29535
29536
29537 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29538 PyObject *resultobj = 0;
29539 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29540 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29541 bool result;
29542 void *argp1 = 0 ;
29543 int res1 = 0 ;
29544 void *argp2 = 0 ;
29545 int res2 = 0 ;
29546 PyObject * obj0 = 0 ;
29547 PyObject * obj1 = 0 ;
29548 char * kwnames[] = {
29549 (char *) "self",(char *) "other", NULL
29550 };
29551
29552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29554 if (!SWIG_IsOK(res1)) {
29555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29556 }
29557 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29558 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29559 if (!SWIG_IsOK(res2)) {
29560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29561 }
29562 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29563 {
29564 PyThreadState* __tstate = wxPyBeginAllowThreads();
29565 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29566 wxPyEndAllowThreads(__tstate);
29567 if (PyErr_Occurred()) SWIG_fail;
29568 }
29569 {
29570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29571 }
29572 return resultobj;
29573 fail:
29574 return NULL;
29575 }
29576
29577
29578 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29579 PyObject *resultobj = 0;
29580 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29581 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29582 bool result;
29583 void *argp1 = 0 ;
29584 int res1 = 0 ;
29585 void *argp2 = 0 ;
29586 int res2 = 0 ;
29587 PyObject * obj0 = 0 ;
29588 PyObject * obj1 = 0 ;
29589 char * kwnames[] = {
29590 (char *) "self",(char *) "other", NULL
29591 };
29592
29593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29595 if (!SWIG_IsOK(res1)) {
29596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29597 }
29598 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29599 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29600 if (!SWIG_IsOK(res2)) {
29601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29602 }
29603 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29607 wxPyEndAllowThreads(__tstate);
29608 if (PyErr_Occurred()) SWIG_fail;
29609 }
29610 {
29611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29612 }
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29620 PyObject *resultobj = 0;
29621 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29622 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29623 bool result;
29624 void *argp1 = 0 ;
29625 int res1 = 0 ;
29626 void *argp2 = 0 ;
29627 int res2 = 0 ;
29628 PyObject * obj0 = 0 ;
29629 PyObject * obj1 = 0 ;
29630 char * kwnames[] = {
29631 (char *) "self",(char *) "other", NULL
29632 };
29633
29634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29636 if (!SWIG_IsOK(res1)) {
29637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29638 }
29639 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29640 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29641 if (!SWIG_IsOK(res2)) {
29642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29643 }
29644 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29645 {
29646 PyThreadState* __tstate = wxPyBeginAllowThreads();
29647 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29648 wxPyEndAllowThreads(__tstate);
29649 if (PyErr_Occurred()) SWIG_fail;
29650 }
29651 {
29652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29653 }
29654 return resultobj;
29655 fail:
29656 return NULL;
29657 }
29658
29659
29660 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29661 PyObject *resultobj = 0;
29662 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29663 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29664 bool result;
29665 void *argp1 = 0 ;
29666 int res1 = 0 ;
29667 void *argp2 = 0 ;
29668 int res2 = 0 ;
29669 PyObject * obj0 = 0 ;
29670 PyObject * obj1 = 0 ;
29671 char * kwnames[] = {
29672 (char *) "self",(char *) "other", NULL
29673 };
29674
29675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29677 if (!SWIG_IsOK(res1)) {
29678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29679 }
29680 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29681 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29682 if (!SWIG_IsOK(res2)) {
29683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29684 }
29685 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29686 {
29687 PyThreadState* __tstate = wxPyBeginAllowThreads();
29688 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29689 wxPyEndAllowThreads(__tstate);
29690 if (PyErr_Occurred()) SWIG_fail;
29691 }
29692 {
29693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29694 }
29695 return resultobj;
29696 fail:
29697 return NULL;
29698 }
29699
29700
29701 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29702 PyObject *resultobj = 0;
29703 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29704 bool result;
29705 void *argp1 = 0 ;
29706 int res1 = 0 ;
29707 PyObject *swig_obj[1] ;
29708
29709 if (!args) SWIG_fail;
29710 swig_obj[0] = args;
29711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29712 if (!SWIG_IsOK(res1)) {
29713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29714 }
29715 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29716 {
29717 PyThreadState* __tstate = wxPyBeginAllowThreads();
29718 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29719 wxPyEndAllowThreads(__tstate);
29720 if (PyErr_Occurred()) SWIG_fail;
29721 }
29722 {
29723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29724 }
29725 return resultobj;
29726 fail:
29727 return NULL;
29728 }
29729
29730
29731 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29732 PyObject *resultobj = 0;
29733 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29734 bool result;
29735 void *argp1 = 0 ;
29736 int res1 = 0 ;
29737 PyObject *swig_obj[1] ;
29738
29739 if (!args) SWIG_fail;
29740 swig_obj[0] = args;
29741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29742 if (!SWIG_IsOK(res1)) {
29743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29744 }
29745 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29749 wxPyEndAllowThreads(__tstate);
29750 if (PyErr_Occurred()) SWIG_fail;
29751 }
29752 {
29753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29754 }
29755 return resultobj;
29756 fail:
29757 return NULL;
29758 }
29759
29760
29761 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29762 PyObject *resultobj = 0;
29763 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29764 bool result;
29765 void *argp1 = 0 ;
29766 int res1 = 0 ;
29767 PyObject *swig_obj[1] ;
29768
29769 if (!args) SWIG_fail;
29770 swig_obj[0] = args;
29771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29772 if (!SWIG_IsOK(res1)) {
29773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29774 }
29775 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29776 {
29777 PyThreadState* __tstate = wxPyBeginAllowThreads();
29778 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29779 wxPyEndAllowThreads(__tstate);
29780 if (PyErr_Occurred()) SWIG_fail;
29781 }
29782 {
29783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29784 }
29785 return resultobj;
29786 fail:
29787 return NULL;
29788 }
29789
29790
29791 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29792 PyObject *resultobj = 0;
29793 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29794 wxTimeSpan *arg2 = 0 ;
29795 bool result;
29796 void *argp1 = 0 ;
29797 int res1 = 0 ;
29798 void *argp2 = 0 ;
29799 int res2 = 0 ;
29800 PyObject * obj0 = 0 ;
29801 PyObject * obj1 = 0 ;
29802 char * kwnames[] = {
29803 (char *) "self",(char *) "ts", NULL
29804 };
29805
29806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29808 if (!SWIG_IsOK(res1)) {
29809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29810 }
29811 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29813 if (!SWIG_IsOK(res2)) {
29814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29815 }
29816 if (!argp2) {
29817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29818 }
29819 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29820 {
29821 PyThreadState* __tstate = wxPyBeginAllowThreads();
29822 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29823 wxPyEndAllowThreads(__tstate);
29824 if (PyErr_Occurred()) SWIG_fail;
29825 }
29826 {
29827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29828 }
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29836 PyObject *resultobj = 0;
29837 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29838 wxTimeSpan *arg2 = 0 ;
29839 bool result;
29840 void *argp1 = 0 ;
29841 int res1 = 0 ;
29842 void *argp2 = 0 ;
29843 int res2 = 0 ;
29844 PyObject * obj0 = 0 ;
29845 PyObject * obj1 = 0 ;
29846 char * kwnames[] = {
29847 (char *) "self",(char *) "ts", NULL
29848 };
29849
29850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29852 if (!SWIG_IsOK(res1)) {
29853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29854 }
29855 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29856 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29857 if (!SWIG_IsOK(res2)) {
29858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29859 }
29860 if (!argp2) {
29861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29862 }
29863 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29864 {
29865 PyThreadState* __tstate = wxPyBeginAllowThreads();
29866 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29867 wxPyEndAllowThreads(__tstate);
29868 if (PyErr_Occurred()) SWIG_fail;
29869 }
29870 {
29871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29872 }
29873 return resultobj;
29874 fail:
29875 return NULL;
29876 }
29877
29878
29879 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29880 PyObject *resultobj = 0;
29881 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29882 wxTimeSpan *arg2 = 0 ;
29883 bool result;
29884 void *argp1 = 0 ;
29885 int res1 = 0 ;
29886 void *argp2 = 0 ;
29887 int res2 = 0 ;
29888 PyObject * obj0 = 0 ;
29889 PyObject * obj1 = 0 ;
29890 char * kwnames[] = {
29891 (char *) "self",(char *) "t", NULL
29892 };
29893
29894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29896 if (!SWIG_IsOK(res1)) {
29897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29898 }
29899 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29900 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29901 if (!SWIG_IsOK(res2)) {
29902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29903 }
29904 if (!argp2) {
29905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29906 }
29907 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29908 {
29909 PyThreadState* __tstate = wxPyBeginAllowThreads();
29910 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
29911 wxPyEndAllowThreads(__tstate);
29912 if (PyErr_Occurred()) SWIG_fail;
29913 }
29914 {
29915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29916 }
29917 return resultobj;
29918 fail:
29919 return NULL;
29920 }
29921
29922
29923 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29924 PyObject *resultobj = 0;
29925 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29926 int result;
29927 void *argp1 = 0 ;
29928 int res1 = 0 ;
29929 PyObject *swig_obj[1] ;
29930
29931 if (!args) SWIG_fail;
29932 swig_obj[0] = args;
29933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29934 if (!SWIG_IsOK(res1)) {
29935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29936 }
29937 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29938 {
29939 PyThreadState* __tstate = wxPyBeginAllowThreads();
29940 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 resultobj = SWIG_From_int(static_cast< int >(result));
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29952 PyObject *resultobj = 0;
29953 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29954 int result;
29955 void *argp1 = 0 ;
29956 int res1 = 0 ;
29957 PyObject *swig_obj[1] ;
29958
29959 if (!args) SWIG_fail;
29960 swig_obj[0] = args;
29961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29962 if (!SWIG_IsOK(res1)) {
29963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29964 }
29965 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29966 {
29967 PyThreadState* __tstate = wxPyBeginAllowThreads();
29968 result = (int)((wxTimeSpan const *)arg1)->GetDays();
29969 wxPyEndAllowThreads(__tstate);
29970 if (PyErr_Occurred()) SWIG_fail;
29971 }
29972 resultobj = SWIG_From_int(static_cast< int >(result));
29973 return resultobj;
29974 fail:
29975 return NULL;
29976 }
29977
29978
29979 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(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_GetHours" "', 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)->GetHours();
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_GetMinutes(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_GetMinutes" "', 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)->GetMinutes();
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_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30036 PyObject *resultobj = 0;
30037 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30038 wxLongLong 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_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30048 }
30049 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30050 {
30051 PyThreadState* __tstate = wxPyBeginAllowThreads();
30052 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30053 wxPyEndAllowThreads(__tstate);
30054 if (PyErr_Occurred()) SWIG_fail;
30055 }
30056 {
30057 PyObject *hi, *lo, *shifter, *shifted;
30058 hi = PyLong_FromLong( (&result)->GetHi() );
30059 lo = PyLong_FromLong( (&result)->GetLo() );
30060 shifter = PyLong_FromLong(32);
30061 shifted = PyNumber_Lshift(hi, shifter);
30062 resultobj = PyNumber_Or(shifted, lo);
30063 Py_DECREF(hi);
30064 Py_DECREF(lo);
30065 Py_DECREF(shifter);
30066 Py_DECREF(shifted);
30067 }
30068 return resultobj;
30069 fail:
30070 return NULL;
30071 }
30072
30073
30074 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30075 PyObject *resultobj = 0;
30076 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30077 wxLongLong result;
30078 void *argp1 = 0 ;
30079 int res1 = 0 ;
30080 PyObject *swig_obj[1] ;
30081
30082 if (!args) SWIG_fail;
30083 swig_obj[0] = args;
30084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30085 if (!SWIG_IsOK(res1)) {
30086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30087 }
30088 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30089 {
30090 PyThreadState* __tstate = wxPyBeginAllowThreads();
30091 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30092 wxPyEndAllowThreads(__tstate);
30093 if (PyErr_Occurred()) SWIG_fail;
30094 }
30095 {
30096 PyObject *hi, *lo, *shifter, *shifted;
30097 hi = PyLong_FromLong( (&result)->GetHi() );
30098 lo = PyLong_FromLong( (&result)->GetLo() );
30099 shifter = PyLong_FromLong(32);
30100 shifted = PyNumber_Lshift(hi, shifter);
30101 resultobj = PyNumber_Or(shifted, lo);
30102 Py_DECREF(hi);
30103 Py_DECREF(lo);
30104 Py_DECREF(shifter);
30105 Py_DECREF(shifted);
30106 }
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30114 PyObject *resultobj = 0;
30115 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30116 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30117 wxString *arg2 = (wxString *) &arg2_defvalue ;
30118 wxString result;
30119 void *argp1 = 0 ;
30120 int res1 = 0 ;
30121 bool temp2 = false ;
30122 PyObject * obj0 = 0 ;
30123 PyObject * obj1 = 0 ;
30124 char * kwnames[] = {
30125 (char *) "self",(char *) "format", NULL
30126 };
30127
30128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30130 if (!SWIG_IsOK(res1)) {
30131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30132 }
30133 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30134 if (obj1) {
30135 {
30136 arg2 = wxString_in_helper(obj1);
30137 if (arg2 == NULL) SWIG_fail;
30138 temp2 = true;
30139 }
30140 }
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30144 wxPyEndAllowThreads(__tstate);
30145 if (PyErr_Occurred()) SWIG_fail;
30146 }
30147 {
30148 #if wxUSE_UNICODE
30149 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30150 #else
30151 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30152 #endif
30153 }
30154 {
30155 if (temp2)
30156 delete arg2;
30157 }
30158 return resultobj;
30159 fail:
30160 {
30161 if (temp2)
30162 delete arg2;
30163 }
30164 return NULL;
30165 }
30166
30167
30168 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30169 PyObject *obj;
30170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30171 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30172 return SWIG_Py_Void();
30173 }
30174
30175 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30176 return SWIG_Python_InitShadowInstance(args);
30177 }
30178
30179 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30180 PyObject *resultobj = 0;
30181 int arg1 = (int) 0 ;
30182 int arg2 = (int) 0 ;
30183 int arg3 = (int) 0 ;
30184 int arg4 = (int) 0 ;
30185 wxDateSpan *result = 0 ;
30186 int val1 ;
30187 int ecode1 = 0 ;
30188 int val2 ;
30189 int ecode2 = 0 ;
30190 int val3 ;
30191 int ecode3 = 0 ;
30192 int val4 ;
30193 int ecode4 = 0 ;
30194 PyObject * obj0 = 0 ;
30195 PyObject * obj1 = 0 ;
30196 PyObject * obj2 = 0 ;
30197 PyObject * obj3 = 0 ;
30198 char * kwnames[] = {
30199 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30200 };
30201
30202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30203 if (obj0) {
30204 ecode1 = SWIG_AsVal_int(obj0, &val1);
30205 if (!SWIG_IsOK(ecode1)) {
30206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30207 }
30208 arg1 = static_cast< int >(val1);
30209 }
30210 if (obj1) {
30211 ecode2 = SWIG_AsVal_int(obj1, &val2);
30212 if (!SWIG_IsOK(ecode2)) {
30213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30214 }
30215 arg2 = static_cast< int >(val2);
30216 }
30217 if (obj2) {
30218 ecode3 = SWIG_AsVal_int(obj2, &val3);
30219 if (!SWIG_IsOK(ecode3)) {
30220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30221 }
30222 arg3 = static_cast< int >(val3);
30223 }
30224 if (obj3) {
30225 ecode4 = SWIG_AsVal_int(obj3, &val4);
30226 if (!SWIG_IsOK(ecode4)) {
30227 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30228 }
30229 arg4 = static_cast< int >(val4);
30230 }
30231 {
30232 PyThreadState* __tstate = wxPyBeginAllowThreads();
30233 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30234 wxPyEndAllowThreads(__tstate);
30235 if (PyErr_Occurred()) SWIG_fail;
30236 }
30237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30238 return resultobj;
30239 fail:
30240 return NULL;
30241 }
30242
30243
30244 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30245 PyObject *resultobj = 0;
30246 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30247 void *argp1 = 0 ;
30248 int res1 = 0 ;
30249 PyObject *swig_obj[1] ;
30250
30251 if (!args) SWIG_fail;
30252 swig_obj[0] = args;
30253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30254 if (!SWIG_IsOK(res1)) {
30255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30256 }
30257 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30258 {
30259 PyThreadState* __tstate = wxPyBeginAllowThreads();
30260 delete arg1;
30261
30262 wxPyEndAllowThreads(__tstate);
30263 if (PyErr_Occurred()) SWIG_fail;
30264 }
30265 resultobj = SWIG_Py_Void();
30266 return resultobj;
30267 fail:
30268 return NULL;
30269 }
30270
30271
30272 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30273 PyObject *resultobj = 0;
30274 int arg1 ;
30275 wxDateSpan result;
30276 int val1 ;
30277 int ecode1 = 0 ;
30278 PyObject * obj0 = 0 ;
30279 char * kwnames[] = {
30280 (char *) "days", NULL
30281 };
30282
30283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30284 ecode1 = SWIG_AsVal_int(obj0, &val1);
30285 if (!SWIG_IsOK(ecode1)) {
30286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30287 }
30288 arg1 = static_cast< int >(val1);
30289 {
30290 PyThreadState* __tstate = wxPyBeginAllowThreads();
30291 result = wxDateSpan::Days(arg1);
30292 wxPyEndAllowThreads(__tstate);
30293 if (PyErr_Occurred()) SWIG_fail;
30294 }
30295 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30296 return resultobj;
30297 fail:
30298 return NULL;
30299 }
30300
30301
30302 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30303 PyObject *resultobj = 0;
30304 wxDateSpan result;
30305
30306 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 result = wxDateSpan::Day();
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30321 PyObject *resultobj = 0;
30322 int arg1 ;
30323 wxDateSpan result;
30324 int val1 ;
30325 int ecode1 = 0 ;
30326 PyObject * obj0 = 0 ;
30327 char * kwnames[] = {
30328 (char *) "weeks", NULL
30329 };
30330
30331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30332 ecode1 = SWIG_AsVal_int(obj0, &val1);
30333 if (!SWIG_IsOK(ecode1)) {
30334 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30335 }
30336 arg1 = static_cast< int >(val1);
30337 {
30338 PyThreadState* __tstate = wxPyBeginAllowThreads();
30339 result = wxDateSpan::Weeks(arg1);
30340 wxPyEndAllowThreads(__tstate);
30341 if (PyErr_Occurred()) SWIG_fail;
30342 }
30343 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30344 return resultobj;
30345 fail:
30346 return NULL;
30347 }
30348
30349
30350 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30351 PyObject *resultobj = 0;
30352 wxDateSpan result;
30353
30354 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30355 {
30356 PyThreadState* __tstate = wxPyBeginAllowThreads();
30357 result = wxDateSpan::Week();
30358 wxPyEndAllowThreads(__tstate);
30359 if (PyErr_Occurred()) SWIG_fail;
30360 }
30361 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30362 return resultobj;
30363 fail:
30364 return NULL;
30365 }
30366
30367
30368 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30369 PyObject *resultobj = 0;
30370 int arg1 ;
30371 wxDateSpan result;
30372 int val1 ;
30373 int ecode1 = 0 ;
30374 PyObject * obj0 = 0 ;
30375 char * kwnames[] = {
30376 (char *) "mon", NULL
30377 };
30378
30379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30380 ecode1 = SWIG_AsVal_int(obj0, &val1);
30381 if (!SWIG_IsOK(ecode1)) {
30382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30383 }
30384 arg1 = static_cast< int >(val1);
30385 {
30386 PyThreadState* __tstate = wxPyBeginAllowThreads();
30387 result = wxDateSpan::Months(arg1);
30388 wxPyEndAllowThreads(__tstate);
30389 if (PyErr_Occurred()) SWIG_fail;
30390 }
30391 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30392 return resultobj;
30393 fail:
30394 return NULL;
30395 }
30396
30397
30398 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30399 PyObject *resultobj = 0;
30400 wxDateSpan result;
30401
30402 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30403 {
30404 PyThreadState* __tstate = wxPyBeginAllowThreads();
30405 result = wxDateSpan::Month();
30406 wxPyEndAllowThreads(__tstate);
30407 if (PyErr_Occurred()) SWIG_fail;
30408 }
30409 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30410 return resultobj;
30411 fail:
30412 return NULL;
30413 }
30414
30415
30416 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30417 PyObject *resultobj = 0;
30418 int arg1 ;
30419 wxDateSpan result;
30420 int val1 ;
30421 int ecode1 = 0 ;
30422 PyObject * obj0 = 0 ;
30423 char * kwnames[] = {
30424 (char *) "years", NULL
30425 };
30426
30427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30428 ecode1 = SWIG_AsVal_int(obj0, &val1);
30429 if (!SWIG_IsOK(ecode1)) {
30430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30431 }
30432 arg1 = static_cast< int >(val1);
30433 {
30434 PyThreadState* __tstate = wxPyBeginAllowThreads();
30435 result = wxDateSpan::Years(arg1);
30436 wxPyEndAllowThreads(__tstate);
30437 if (PyErr_Occurred()) SWIG_fail;
30438 }
30439 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30440 return resultobj;
30441 fail:
30442 return NULL;
30443 }
30444
30445
30446 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30447 PyObject *resultobj = 0;
30448 wxDateSpan result;
30449
30450 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30451 {
30452 PyThreadState* __tstate = wxPyBeginAllowThreads();
30453 result = wxDateSpan::Year();
30454 wxPyEndAllowThreads(__tstate);
30455 if (PyErr_Occurred()) SWIG_fail;
30456 }
30457 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30458 return resultobj;
30459 fail:
30460 return NULL;
30461 }
30462
30463
30464 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30465 PyObject *resultobj = 0;
30466 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30467 int arg2 ;
30468 wxDateSpan *result = 0 ;
30469 void *argp1 = 0 ;
30470 int res1 = 0 ;
30471 int val2 ;
30472 int ecode2 = 0 ;
30473 PyObject * obj0 = 0 ;
30474 PyObject * obj1 = 0 ;
30475 char * kwnames[] = {
30476 (char *) "self",(char *) "n", NULL
30477 };
30478
30479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30481 if (!SWIG_IsOK(res1)) {
30482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30483 }
30484 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30485 ecode2 = SWIG_AsVal_int(obj1, &val2);
30486 if (!SWIG_IsOK(ecode2)) {
30487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30488 }
30489 arg2 = static_cast< int >(val2);
30490 {
30491 PyThreadState* __tstate = wxPyBeginAllowThreads();
30492 {
30493 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30494 result = (wxDateSpan *) &_result_ref;
30495 }
30496 wxPyEndAllowThreads(__tstate);
30497 if (PyErr_Occurred()) SWIG_fail;
30498 }
30499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30500 return resultobj;
30501 fail:
30502 return NULL;
30503 }
30504
30505
30506 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30507 PyObject *resultobj = 0;
30508 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30509 int arg2 ;
30510 wxDateSpan *result = 0 ;
30511 void *argp1 = 0 ;
30512 int res1 = 0 ;
30513 int val2 ;
30514 int ecode2 = 0 ;
30515 PyObject * obj0 = 0 ;
30516 PyObject * obj1 = 0 ;
30517 char * kwnames[] = {
30518 (char *) "self",(char *) "n", NULL
30519 };
30520
30521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30523 if (!SWIG_IsOK(res1)) {
30524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30525 }
30526 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30527 ecode2 = SWIG_AsVal_int(obj1, &val2);
30528 if (!SWIG_IsOK(ecode2)) {
30529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30530 }
30531 arg2 = static_cast< int >(val2);
30532 {
30533 PyThreadState* __tstate = wxPyBeginAllowThreads();
30534 {
30535 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30536 result = (wxDateSpan *) &_result_ref;
30537 }
30538 wxPyEndAllowThreads(__tstate);
30539 if (PyErr_Occurred()) SWIG_fail;
30540 }
30541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30542 return resultobj;
30543 fail:
30544 return NULL;
30545 }
30546
30547
30548 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30549 PyObject *resultobj = 0;
30550 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30551 int arg2 ;
30552 wxDateSpan *result = 0 ;
30553 void *argp1 = 0 ;
30554 int res1 = 0 ;
30555 int val2 ;
30556 int ecode2 = 0 ;
30557 PyObject * obj0 = 0 ;
30558 PyObject * obj1 = 0 ;
30559 char * kwnames[] = {
30560 (char *) "self",(char *) "n", NULL
30561 };
30562
30563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30565 if (!SWIG_IsOK(res1)) {
30566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30567 }
30568 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30569 ecode2 = SWIG_AsVal_int(obj1, &val2);
30570 if (!SWIG_IsOK(ecode2)) {
30571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30572 }
30573 arg2 = static_cast< int >(val2);
30574 {
30575 PyThreadState* __tstate = wxPyBeginAllowThreads();
30576 {
30577 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30578 result = (wxDateSpan *) &_result_ref;
30579 }
30580 wxPyEndAllowThreads(__tstate);
30581 if (PyErr_Occurred()) SWIG_fail;
30582 }
30583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30584 return resultobj;
30585 fail:
30586 return NULL;
30587 }
30588
30589
30590 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30591 PyObject *resultobj = 0;
30592 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30593 int arg2 ;
30594 wxDateSpan *result = 0 ;
30595 void *argp1 = 0 ;
30596 int res1 = 0 ;
30597 int val2 ;
30598 int ecode2 = 0 ;
30599 PyObject * obj0 = 0 ;
30600 PyObject * obj1 = 0 ;
30601 char * kwnames[] = {
30602 (char *) "self",(char *) "n", NULL
30603 };
30604
30605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30607 if (!SWIG_IsOK(res1)) {
30608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30609 }
30610 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30611 ecode2 = SWIG_AsVal_int(obj1, &val2);
30612 if (!SWIG_IsOK(ecode2)) {
30613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30614 }
30615 arg2 = static_cast< int >(val2);
30616 {
30617 PyThreadState* __tstate = wxPyBeginAllowThreads();
30618 {
30619 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30620 result = (wxDateSpan *) &_result_ref;
30621 }
30622 wxPyEndAllowThreads(__tstate);
30623 if (PyErr_Occurred()) SWIG_fail;
30624 }
30625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30626 return resultobj;
30627 fail:
30628 return NULL;
30629 }
30630
30631
30632 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30633 PyObject *resultobj = 0;
30634 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30635 int result;
30636 void *argp1 = 0 ;
30637 int res1 = 0 ;
30638 PyObject *swig_obj[1] ;
30639
30640 if (!args) SWIG_fail;
30641 swig_obj[0] = args;
30642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30643 if (!SWIG_IsOK(res1)) {
30644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30645 }
30646 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30647 {
30648 PyThreadState* __tstate = wxPyBeginAllowThreads();
30649 result = (int)((wxDateSpan const *)arg1)->GetYears();
30650 wxPyEndAllowThreads(__tstate);
30651 if (PyErr_Occurred()) SWIG_fail;
30652 }
30653 resultobj = SWIG_From_int(static_cast< int >(result));
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30661 PyObject *resultobj = 0;
30662 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30663 int result;
30664 void *argp1 = 0 ;
30665 int res1 = 0 ;
30666 PyObject *swig_obj[1] ;
30667
30668 if (!args) SWIG_fail;
30669 swig_obj[0] = args;
30670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30671 if (!SWIG_IsOK(res1)) {
30672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30673 }
30674 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30675 {
30676 PyThreadState* __tstate = wxPyBeginAllowThreads();
30677 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_From_int(static_cast< int >(result));
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(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_GetWeeks" "', 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)->GetWeeks();
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_GetDays(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_GetDays" "', 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)->GetDays();
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_GetTotalDays(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_GetTotalDays" "', 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)->GetTotalDays();
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_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30773 PyObject *resultobj = 0;
30774 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30775 wxDateSpan *arg2 = 0 ;
30776 wxDateSpan *result = 0 ;
30777 void *argp1 = 0 ;
30778 int res1 = 0 ;
30779 void *argp2 = 0 ;
30780 int res2 = 0 ;
30781 PyObject * obj0 = 0 ;
30782 PyObject * obj1 = 0 ;
30783 char * kwnames[] = {
30784 (char *) "self",(char *) "other", NULL
30785 };
30786
30787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30789 if (!SWIG_IsOK(res1)) {
30790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30791 }
30792 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30793 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30794 if (!SWIG_IsOK(res2)) {
30795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30796 }
30797 if (!argp2) {
30798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30799 }
30800 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 {
30804 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30805 result = (wxDateSpan *) &_result_ref;
30806 }
30807 wxPyEndAllowThreads(__tstate);
30808 if (PyErr_Occurred()) SWIG_fail;
30809 }
30810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30811 return resultobj;
30812 fail:
30813 return NULL;
30814 }
30815
30816
30817 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30818 PyObject *resultobj = 0;
30819 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30820 wxDateSpan *arg2 = 0 ;
30821 wxDateSpan *result = 0 ;
30822 void *argp1 = 0 ;
30823 int res1 = 0 ;
30824 void *argp2 = 0 ;
30825 int res2 = 0 ;
30826 PyObject * obj0 = 0 ;
30827 PyObject * obj1 = 0 ;
30828 char * kwnames[] = {
30829 (char *) "self",(char *) "other", NULL
30830 };
30831
30832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30834 if (!SWIG_IsOK(res1)) {
30835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30836 }
30837 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30839 if (!SWIG_IsOK(res2)) {
30840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30841 }
30842 if (!argp2) {
30843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30844 }
30845 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30846 {
30847 PyThreadState* __tstate = wxPyBeginAllowThreads();
30848 {
30849 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30850 result = (wxDateSpan *) &_result_ref;
30851 }
30852 wxPyEndAllowThreads(__tstate);
30853 if (PyErr_Occurred()) SWIG_fail;
30854 }
30855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30856 return resultobj;
30857 fail:
30858 return NULL;
30859 }
30860
30861
30862 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30863 PyObject *resultobj = 0;
30864 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30865 wxDateSpan *result = 0 ;
30866 void *argp1 = 0 ;
30867 int res1 = 0 ;
30868 PyObject *swig_obj[1] ;
30869
30870 if (!args) SWIG_fail;
30871 swig_obj[0] = args;
30872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30873 if (!SWIG_IsOK(res1)) {
30874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30875 }
30876 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30877 {
30878 PyThreadState* __tstate = wxPyBeginAllowThreads();
30879 {
30880 wxDateSpan &_result_ref = (arg1)->Neg();
30881 result = (wxDateSpan *) &_result_ref;
30882 }
30883 wxPyEndAllowThreads(__tstate);
30884 if (PyErr_Occurred()) SWIG_fail;
30885 }
30886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30887 return resultobj;
30888 fail:
30889 return NULL;
30890 }
30891
30892
30893 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30894 PyObject *resultobj = 0;
30895 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30896 int arg2 ;
30897 wxDateSpan *result = 0 ;
30898 void *argp1 = 0 ;
30899 int res1 = 0 ;
30900 int val2 ;
30901 int ecode2 = 0 ;
30902 PyObject * obj0 = 0 ;
30903 PyObject * obj1 = 0 ;
30904 char * kwnames[] = {
30905 (char *) "self",(char *) "factor", NULL
30906 };
30907
30908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
30909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30910 if (!SWIG_IsOK(res1)) {
30911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30912 }
30913 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30914 ecode2 = SWIG_AsVal_int(obj1, &val2);
30915 if (!SWIG_IsOK(ecode2)) {
30916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
30917 }
30918 arg2 = static_cast< int >(val2);
30919 {
30920 PyThreadState* __tstate = wxPyBeginAllowThreads();
30921 {
30922 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
30923 result = (wxDateSpan *) &_result_ref;
30924 }
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30929 return resultobj;
30930 fail:
30931 return NULL;
30932 }
30933
30934
30935 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30936 PyObject *resultobj = 0;
30937 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30938 wxDateSpan *arg2 = 0 ;
30939 wxDateSpan *result = 0 ;
30940 void *argp1 = 0 ;
30941 int res1 = 0 ;
30942 void *argp2 = 0 ;
30943 int res2 = 0 ;
30944 PyObject * obj0 = 0 ;
30945 PyObject * obj1 = 0 ;
30946 char * kwnames[] = {
30947 (char *) "self",(char *) "other", NULL
30948 };
30949
30950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
30951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30952 if (!SWIG_IsOK(res1)) {
30953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30954 }
30955 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30956 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30957 if (!SWIG_IsOK(res2)) {
30958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30959 }
30960 if (!argp2) {
30961 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30962 }
30963 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30964 {
30965 PyThreadState* __tstate = wxPyBeginAllowThreads();
30966 {
30967 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
30968 result = (wxDateSpan *) &_result_ref;
30969 }
30970 wxPyEndAllowThreads(__tstate);
30971 if (PyErr_Occurred()) SWIG_fail;
30972 }
30973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30974 return resultobj;
30975 fail:
30976 return NULL;
30977 }
30978
30979
30980 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30981 PyObject *resultobj = 0;
30982 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30983 wxDateSpan *arg2 = 0 ;
30984 wxDateSpan *result = 0 ;
30985 void *argp1 = 0 ;
30986 int res1 = 0 ;
30987 void *argp2 = 0 ;
30988 int res2 = 0 ;
30989 PyObject * obj0 = 0 ;
30990 PyObject * obj1 = 0 ;
30991 char * kwnames[] = {
30992 (char *) "self",(char *) "other", NULL
30993 };
30994
30995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
30996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30997 if (!SWIG_IsOK(res1)) {
30998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30999 }
31000 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31001 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31002 if (!SWIG_IsOK(res2)) {
31003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31004 }
31005 if (!argp2) {
31006 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31007 }
31008 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 {
31012 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31013 result = (wxDateSpan *) &_result_ref;
31014 }
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31019 return resultobj;
31020 fail:
31021 return NULL;
31022 }
31023
31024
31025 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31026 PyObject *resultobj = 0;
31027 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31028 wxDateSpan *result = 0 ;
31029 void *argp1 = 0 ;
31030 int res1 = 0 ;
31031 PyObject *swig_obj[1] ;
31032
31033 if (!args) SWIG_fail;
31034 swig_obj[0] = args;
31035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31036 if (!SWIG_IsOK(res1)) {
31037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31038 }
31039 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31040 {
31041 PyThreadState* __tstate = wxPyBeginAllowThreads();
31042 {
31043 wxDateSpan &_result_ref = (arg1)->operator -();
31044 result = (wxDateSpan *) &_result_ref;
31045 }
31046 wxPyEndAllowThreads(__tstate);
31047 if (PyErr_Occurred()) SWIG_fail;
31048 }
31049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31050 return resultobj;
31051 fail:
31052 return NULL;
31053 }
31054
31055
31056 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31057 PyObject *resultobj = 0;
31058 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31059 int arg2 ;
31060 wxDateSpan *result = 0 ;
31061 void *argp1 = 0 ;
31062 int res1 = 0 ;
31063 int val2 ;
31064 int ecode2 = 0 ;
31065 PyObject * obj0 = 0 ;
31066 PyObject * obj1 = 0 ;
31067 char * kwnames[] = {
31068 (char *) "self",(char *) "factor", NULL
31069 };
31070
31071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31073 if (!SWIG_IsOK(res1)) {
31074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31075 }
31076 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31077 ecode2 = SWIG_AsVal_int(obj1, &val2);
31078 if (!SWIG_IsOK(ecode2)) {
31079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31080 }
31081 arg2 = static_cast< int >(val2);
31082 {
31083 PyThreadState* __tstate = wxPyBeginAllowThreads();
31084 {
31085 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31086 result = (wxDateSpan *) &_result_ref;
31087 }
31088 wxPyEndAllowThreads(__tstate);
31089 if (PyErr_Occurred()) SWIG_fail;
31090 }
31091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31092 return resultobj;
31093 fail:
31094 return NULL;
31095 }
31096
31097
31098 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31099 PyObject *resultobj = 0;
31100 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31101 wxDateSpan *arg2 = 0 ;
31102 wxDateSpan result;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 void *argp2 = 0 ;
31106 int res2 = 0 ;
31107 PyObject * obj0 = 0 ;
31108 PyObject * obj1 = 0 ;
31109 char * kwnames[] = {
31110 (char *) "self",(char *) "other", NULL
31111 };
31112
31113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31115 if (!SWIG_IsOK(res1)) {
31116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31117 }
31118 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31120 if (!SWIG_IsOK(res2)) {
31121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31122 }
31123 if (!argp2) {
31124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31125 }
31126 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31127 {
31128 PyThreadState* __tstate = wxPyBeginAllowThreads();
31129 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj = 0;
31142 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31143 wxDateSpan *arg2 = 0 ;
31144 wxDateSpan result;
31145 void *argp1 = 0 ;
31146 int res1 = 0 ;
31147 void *argp2 = 0 ;
31148 int res2 = 0 ;
31149 PyObject * obj0 = 0 ;
31150 PyObject * obj1 = 0 ;
31151 char * kwnames[] = {
31152 (char *) "self",(char *) "other", NULL
31153 };
31154
31155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31157 if (!SWIG_IsOK(res1)) {
31158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31159 }
31160 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31161 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31162 if (!SWIG_IsOK(res2)) {
31163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31164 }
31165 if (!argp2) {
31166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31167 }
31168 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31169 {
31170 PyThreadState* __tstate = wxPyBeginAllowThreads();
31171 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31172 wxPyEndAllowThreads(__tstate);
31173 if (PyErr_Occurred()) SWIG_fail;
31174 }
31175 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31176 return resultobj;
31177 fail:
31178 return NULL;
31179 }
31180
31181
31182 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31183 PyObject *resultobj = 0;
31184 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31185 int arg2 ;
31186 wxDateSpan result;
31187 void *argp1 = 0 ;
31188 int res1 = 0 ;
31189 int val2 ;
31190 int ecode2 = 0 ;
31191 PyObject * obj0 = 0 ;
31192 PyObject * obj1 = 0 ;
31193 char * kwnames[] = {
31194 (char *) "self",(char *) "n", NULL
31195 };
31196
31197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31199 if (!SWIG_IsOK(res1)) {
31200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31201 }
31202 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31203 ecode2 = SWIG_AsVal_int(obj1, &val2);
31204 if (!SWIG_IsOK(ecode2)) {
31205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31206 }
31207 arg2 = static_cast< int >(val2);
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 result = wxDateSpan___mul__(arg1,arg2);
31211 wxPyEndAllowThreads(__tstate);
31212 if (PyErr_Occurred()) SWIG_fail;
31213 }
31214 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31222 PyObject *resultobj = 0;
31223 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31224 int arg2 ;
31225 wxDateSpan result;
31226 void *argp1 = 0 ;
31227 int res1 = 0 ;
31228 int val2 ;
31229 int ecode2 = 0 ;
31230 PyObject * obj0 = 0 ;
31231 PyObject * obj1 = 0 ;
31232 char * kwnames[] = {
31233 (char *) "self",(char *) "n", NULL
31234 };
31235
31236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31238 if (!SWIG_IsOK(res1)) {
31239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31240 }
31241 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31242 ecode2 = SWIG_AsVal_int(obj1, &val2);
31243 if (!SWIG_IsOK(ecode2)) {
31244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31245 }
31246 arg2 = static_cast< int >(val2);
31247 {
31248 PyThreadState* __tstate = wxPyBeginAllowThreads();
31249 result = wxDateSpan___rmul__(arg1,arg2);
31250 wxPyEndAllowThreads(__tstate);
31251 if (PyErr_Occurred()) SWIG_fail;
31252 }
31253 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31254 return resultobj;
31255 fail:
31256 return NULL;
31257 }
31258
31259
31260 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31261 PyObject *resultobj = 0;
31262 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31263 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31264 bool result;
31265 void *argp1 = 0 ;
31266 int res1 = 0 ;
31267 void *argp2 = 0 ;
31268 int res2 = 0 ;
31269 PyObject * obj0 = 0 ;
31270 PyObject * obj1 = 0 ;
31271 char * kwnames[] = {
31272 (char *) "self",(char *) "other", NULL
31273 };
31274
31275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31277 if (!SWIG_IsOK(res1)) {
31278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31279 }
31280 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31282 if (!SWIG_IsOK(res2)) {
31283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31284 }
31285 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31286 {
31287 PyThreadState* __tstate = wxPyBeginAllowThreads();
31288 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31289 wxPyEndAllowThreads(__tstate);
31290 if (PyErr_Occurred()) SWIG_fail;
31291 }
31292 {
31293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31294 }
31295 return resultobj;
31296 fail:
31297 return NULL;
31298 }
31299
31300
31301 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31302 PyObject *resultobj = 0;
31303 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31304 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31305 bool result;
31306 void *argp1 = 0 ;
31307 int res1 = 0 ;
31308 void *argp2 = 0 ;
31309 int res2 = 0 ;
31310 PyObject * obj0 = 0 ;
31311 PyObject * obj1 = 0 ;
31312 char * kwnames[] = {
31313 (char *) "self",(char *) "other", NULL
31314 };
31315
31316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31318 if (!SWIG_IsOK(res1)) {
31319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31320 }
31321 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31323 if (!SWIG_IsOK(res2)) {
31324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31325 }
31326 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31327 {
31328 PyThreadState* __tstate = wxPyBeginAllowThreads();
31329 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31330 wxPyEndAllowThreads(__tstate);
31331 if (PyErr_Occurred()) SWIG_fail;
31332 }
31333 {
31334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31335 }
31336 return resultobj;
31337 fail:
31338 return NULL;
31339 }
31340
31341
31342 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31343 PyObject *obj;
31344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31345 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31346 return SWIG_Py_Void();
31347 }
31348
31349 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31350 return SWIG_Python_InitShadowInstance(args);
31351 }
31352
31353 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31354 PyObject *resultobj = 0;
31355 long result;
31356
31357 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31358 {
31359 PyThreadState* __tstate = wxPyBeginAllowThreads();
31360 result = (long)wxGetLocalTime();
31361 wxPyEndAllowThreads(__tstate);
31362 if (PyErr_Occurred()) SWIG_fail;
31363 }
31364 resultobj = SWIG_From_long(static_cast< long >(result));
31365 return resultobj;
31366 fail:
31367 return NULL;
31368 }
31369
31370
31371 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31372 PyObject *resultobj = 0;
31373 long result;
31374
31375 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31376 {
31377 PyThreadState* __tstate = wxPyBeginAllowThreads();
31378 result = (long)wxGetUTCTime();
31379 wxPyEndAllowThreads(__tstate);
31380 if (PyErr_Occurred()) SWIG_fail;
31381 }
31382 resultobj = SWIG_From_long(static_cast< long >(result));
31383 return resultobj;
31384 fail:
31385 return NULL;
31386 }
31387
31388
31389 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31390 PyObject *resultobj = 0;
31391 long result;
31392
31393 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31394 {
31395 PyThreadState* __tstate = wxPyBeginAllowThreads();
31396 result = (long)wxGetCurrentTime();
31397 wxPyEndAllowThreads(__tstate);
31398 if (PyErr_Occurred()) SWIG_fail;
31399 }
31400 resultobj = SWIG_From_long(static_cast< long >(result));
31401 return resultobj;
31402 fail:
31403 return NULL;
31404 }
31405
31406
31407 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31408 PyObject *resultobj = 0;
31409 wxLongLong result;
31410
31411 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31412 {
31413 PyThreadState* __tstate = wxPyBeginAllowThreads();
31414 result = wxGetLocalTimeMillis();
31415 wxPyEndAllowThreads(__tstate);
31416 if (PyErr_Occurred()) SWIG_fail;
31417 }
31418 {
31419 PyObject *hi, *lo, *shifter, *shifted;
31420 hi = PyLong_FromLong( (&result)->GetHi() );
31421 lo = PyLong_FromLong( (&result)->GetLo() );
31422 shifter = PyLong_FromLong(32);
31423 shifted = PyNumber_Lshift(hi, shifter);
31424 resultobj = PyNumber_Or(shifted, lo);
31425 Py_DECREF(hi);
31426 Py_DECREF(lo);
31427 Py_DECREF(shifter);
31428 Py_DECREF(shifted);
31429 }
31430 return resultobj;
31431 fail:
31432 return NULL;
31433 }
31434
31435
31436 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31437 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31438 return 1;
31439 }
31440
31441
31442 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31443 PyObject *pyobj = 0;
31444
31445 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31446 return pyobj;
31447 }
31448
31449
31450 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31451 PyObject *resultobj = 0;
31452 wxDataFormatId arg1 ;
31453 wxDataFormat *result = 0 ;
31454 int val1 ;
31455 int ecode1 = 0 ;
31456 PyObject * obj0 = 0 ;
31457 char * kwnames[] = {
31458 (char *) "type", NULL
31459 };
31460
31461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31462 ecode1 = SWIG_AsVal_int(obj0, &val1);
31463 if (!SWIG_IsOK(ecode1)) {
31464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31465 }
31466 arg1 = static_cast< wxDataFormatId >(val1);
31467 {
31468 PyThreadState* __tstate = wxPyBeginAllowThreads();
31469 result = (wxDataFormat *)new wxDataFormat(arg1);
31470 wxPyEndAllowThreads(__tstate);
31471 if (PyErr_Occurred()) SWIG_fail;
31472 }
31473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31474 return resultobj;
31475 fail:
31476 return NULL;
31477 }
31478
31479
31480 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31481 PyObject *resultobj = 0;
31482 wxString *arg1 = 0 ;
31483 wxDataFormat *result = 0 ;
31484 bool temp1 = false ;
31485 PyObject * obj0 = 0 ;
31486 char * kwnames[] = {
31487 (char *) "format", NULL
31488 };
31489
31490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31491 {
31492 arg1 = wxString_in_helper(obj0);
31493 if (arg1 == NULL) SWIG_fail;
31494 temp1 = true;
31495 }
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31499 wxPyEndAllowThreads(__tstate);
31500 if (PyErr_Occurred()) SWIG_fail;
31501 }
31502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31503 {
31504 if (temp1)
31505 delete arg1;
31506 }
31507 return resultobj;
31508 fail:
31509 {
31510 if (temp1)
31511 delete arg1;
31512 }
31513 return NULL;
31514 }
31515
31516
31517 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31518 PyObject *resultobj = 0;
31519 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31520 void *argp1 = 0 ;
31521 int res1 = 0 ;
31522 PyObject *swig_obj[1] ;
31523
31524 if (!args) SWIG_fail;
31525 swig_obj[0] = args;
31526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31527 if (!SWIG_IsOK(res1)) {
31528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31529 }
31530 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 delete arg1;
31534
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 resultobj = SWIG_Py_Void();
31539 return resultobj;
31540 fail:
31541 return NULL;
31542 }
31543
31544
31545 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31546 PyObject *resultobj = 0;
31547 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31548 wxDataFormatId arg2 ;
31549 bool result;
31550 void *argp1 = 0 ;
31551 int res1 = 0 ;
31552 int val2 ;
31553 int ecode2 = 0 ;
31554
31555 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31557 if (!SWIG_IsOK(res1)) {
31558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31559 }
31560 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31561 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31562 if (!SWIG_IsOK(ecode2)) {
31563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31564 }
31565 arg2 = static_cast< wxDataFormatId >(val2);
31566 {
31567 PyThreadState* __tstate = wxPyBeginAllowThreads();
31568 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31569 wxPyEndAllowThreads(__tstate);
31570 if (PyErr_Occurred()) SWIG_fail;
31571 }
31572 {
31573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31574 }
31575 return resultobj;
31576 fail:
31577 return NULL;
31578 }
31579
31580
31581 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31582 PyObject *resultobj = 0;
31583 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31584 wxDataFormatId arg2 ;
31585 bool result;
31586 void *argp1 = 0 ;
31587 int res1 = 0 ;
31588 int val2 ;
31589 int ecode2 = 0 ;
31590
31591 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31593 if (!SWIG_IsOK(res1)) {
31594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31595 }
31596 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31597 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31598 if (!SWIG_IsOK(ecode2)) {
31599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31600 }
31601 arg2 = static_cast< wxDataFormatId >(val2);
31602 {
31603 PyThreadState* __tstate = wxPyBeginAllowThreads();
31604 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31605 wxPyEndAllowThreads(__tstate);
31606 if (PyErr_Occurred()) SWIG_fail;
31607 }
31608 {
31609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31610 }
31611 return resultobj;
31612 fail:
31613 return NULL;
31614 }
31615
31616
31617 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31618 PyObject *resultobj = 0;
31619 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31620 wxDataFormat *arg2 = 0 ;
31621 bool result;
31622 void *argp1 = 0 ;
31623 int res1 = 0 ;
31624 void *argp2 = 0 ;
31625 int res2 = 0 ;
31626
31627 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31629 if (!SWIG_IsOK(res1)) {
31630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31631 }
31632 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31633 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31634 if (!SWIG_IsOK(res2)) {
31635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31636 }
31637 if (!argp2) {
31638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31639 }
31640 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31641 {
31642 PyThreadState* __tstate = wxPyBeginAllowThreads();
31643 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31644 wxPyEndAllowThreads(__tstate);
31645 if (PyErr_Occurred()) SWIG_fail;
31646 }
31647 {
31648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31649 }
31650 return resultobj;
31651 fail:
31652 return NULL;
31653 }
31654
31655
31656 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31657 int argc;
31658 PyObject *argv[3];
31659
31660 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31661 --argc;
31662 if (argc == 2) {
31663 int _v = 0;
31664 {
31665 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31666 _v = SWIG_CheckState(res);
31667 }
31668 if (!_v) goto check_1;
31669 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31670 }
31671 check_1:
31672
31673 if (argc == 2) {
31674 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31675 }
31676
31677 fail:
31678 Py_INCREF(Py_NotImplemented);
31679 return Py_NotImplemented;
31680 }
31681
31682
31683 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31684 PyObject *resultobj = 0;
31685 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31686 wxDataFormat *arg2 = 0 ;
31687 bool result;
31688 void *argp1 = 0 ;
31689 int res1 = 0 ;
31690 void *argp2 = 0 ;
31691 int res2 = 0 ;
31692
31693 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31695 if (!SWIG_IsOK(res1)) {
31696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31697 }
31698 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31699 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31700 if (!SWIG_IsOK(res2)) {
31701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31702 }
31703 if (!argp2) {
31704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31705 }
31706 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31707 {
31708 PyThreadState* __tstate = wxPyBeginAllowThreads();
31709 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31710 wxPyEndAllowThreads(__tstate);
31711 if (PyErr_Occurred()) SWIG_fail;
31712 }
31713 {
31714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31715 }
31716 return resultobj;
31717 fail:
31718 return NULL;
31719 }
31720
31721
31722 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31723 int argc;
31724 PyObject *argv[3];
31725
31726 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31727 --argc;
31728 if (argc == 2) {
31729 int _v = 0;
31730 {
31731 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31732 _v = SWIG_CheckState(res);
31733 }
31734 if (!_v) goto check_1;
31735 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31736 }
31737 check_1:
31738
31739 if (argc == 2) {
31740 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31741 }
31742
31743 fail:
31744 Py_INCREF(Py_NotImplemented);
31745 return Py_NotImplemented;
31746 }
31747
31748
31749 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31750 PyObject *resultobj = 0;
31751 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31752 wxDataFormatId arg2 ;
31753 void *argp1 = 0 ;
31754 int res1 = 0 ;
31755 int val2 ;
31756 int ecode2 = 0 ;
31757 PyObject * obj0 = 0 ;
31758 PyObject * obj1 = 0 ;
31759 char * kwnames[] = {
31760 (char *) "self",(char *) "format", NULL
31761 };
31762
31763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31765 if (!SWIG_IsOK(res1)) {
31766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31767 }
31768 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31769 ecode2 = SWIG_AsVal_int(obj1, &val2);
31770 if (!SWIG_IsOK(ecode2)) {
31771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31772 }
31773 arg2 = static_cast< wxDataFormatId >(val2);
31774 {
31775 PyThreadState* __tstate = wxPyBeginAllowThreads();
31776 (arg1)->SetType(arg2);
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 resultobj = SWIG_Py_Void();
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31788 PyObject *resultobj = 0;
31789 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31790 wxDataFormatId result;
31791 void *argp1 = 0 ;
31792 int res1 = 0 ;
31793 PyObject *swig_obj[1] ;
31794
31795 if (!args) SWIG_fail;
31796 swig_obj[0] = args;
31797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31798 if (!SWIG_IsOK(res1)) {
31799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31800 }
31801 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31805 wxPyEndAllowThreads(__tstate);
31806 if (PyErr_Occurred()) SWIG_fail;
31807 }
31808 resultobj = SWIG_From_int(static_cast< int >(result));
31809 return resultobj;
31810 fail:
31811 return NULL;
31812 }
31813
31814
31815 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31816 PyObject *resultobj = 0;
31817 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31818 wxString result;
31819 void *argp1 = 0 ;
31820 int res1 = 0 ;
31821 PyObject *swig_obj[1] ;
31822
31823 if (!args) SWIG_fail;
31824 swig_obj[0] = args;
31825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31826 if (!SWIG_IsOK(res1)) {
31827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31828 }
31829 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31830 {
31831 PyThreadState* __tstate = wxPyBeginAllowThreads();
31832 result = ((wxDataFormat const *)arg1)->GetId();
31833 wxPyEndAllowThreads(__tstate);
31834 if (PyErr_Occurred()) SWIG_fail;
31835 }
31836 {
31837 #if wxUSE_UNICODE
31838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31839 #else
31840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31841 #endif
31842 }
31843 return resultobj;
31844 fail:
31845 return NULL;
31846 }
31847
31848
31849 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31850 PyObject *resultobj = 0;
31851 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31852 wxString *arg2 = 0 ;
31853 void *argp1 = 0 ;
31854 int res1 = 0 ;
31855 bool temp2 = false ;
31856 PyObject * obj0 = 0 ;
31857 PyObject * obj1 = 0 ;
31858 char * kwnames[] = {
31859 (char *) "self",(char *) "format", NULL
31860 };
31861
31862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31864 if (!SWIG_IsOK(res1)) {
31865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31866 }
31867 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31868 {
31869 arg2 = wxString_in_helper(obj1);
31870 if (arg2 == NULL) SWIG_fail;
31871 temp2 = true;
31872 }
31873 {
31874 PyThreadState* __tstate = wxPyBeginAllowThreads();
31875 (arg1)->SetId((wxString const &)*arg2);
31876 wxPyEndAllowThreads(__tstate);
31877 if (PyErr_Occurred()) SWIG_fail;
31878 }
31879 resultobj = SWIG_Py_Void();
31880 {
31881 if (temp2)
31882 delete arg2;
31883 }
31884 return resultobj;
31885 fail:
31886 {
31887 if (temp2)
31888 delete arg2;
31889 }
31890 return NULL;
31891 }
31892
31893
31894 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31895 PyObject *obj;
31896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31897 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31898 return SWIG_Py_Void();
31899 }
31900
31901 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31902 return SWIG_Python_InitShadowInstance(args);
31903 }
31904
31905 SWIGINTERN int FormatInvalid_set(PyObject *) {
31906 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
31907 return 1;
31908 }
31909
31910
31911 SWIGINTERN PyObject *FormatInvalid_get(void) {
31912 PyObject *pyobj = 0;
31913
31914 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
31915 return pyobj;
31916 }
31917
31918
31919 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31920 PyObject *resultobj = 0;
31921 wxDataObject *arg1 = (wxDataObject *) 0 ;
31922 void *argp1 = 0 ;
31923 int res1 = 0 ;
31924 PyObject *swig_obj[1] ;
31925
31926 if (!args) SWIG_fail;
31927 swig_obj[0] = args;
31928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
31929 if (!SWIG_IsOK(res1)) {
31930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
31931 }
31932 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 delete arg1;
31936
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 resultobj = SWIG_Py_Void();
31941 return resultobj;
31942 fail:
31943 return NULL;
31944 }
31945
31946
31947 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31948 PyObject *resultobj = 0;
31949 wxDataObject *arg1 = (wxDataObject *) 0 ;
31950 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31951 SwigValueWrapper<wxDataFormat > result;
31952 void *argp1 = 0 ;
31953 int res1 = 0 ;
31954 int val2 ;
31955 int ecode2 = 0 ;
31956 PyObject * obj0 = 0 ;
31957 PyObject * obj1 = 0 ;
31958 char * kwnames[] = {
31959 (char *) "self",(char *) "dir", NULL
31960 };
31961
31962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31964 if (!SWIG_IsOK(res1)) {
31965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31966 }
31967 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31968 if (obj1) {
31969 ecode2 = SWIG_AsVal_int(obj1, &val2);
31970 if (!SWIG_IsOK(ecode2)) {
31971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31972 }
31973 arg2 = static_cast< wxDataObject::Direction >(val2);
31974 }
31975 {
31976 PyThreadState* __tstate = wxPyBeginAllowThreads();
31977 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
31978 wxPyEndAllowThreads(__tstate);
31979 if (PyErr_Occurred()) SWIG_fail;
31980 }
31981 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31982 return resultobj;
31983 fail:
31984 return NULL;
31985 }
31986
31987
31988 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31989 PyObject *resultobj = 0;
31990 wxDataObject *arg1 = (wxDataObject *) 0 ;
31991 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31992 size_t result;
31993 void *argp1 = 0 ;
31994 int res1 = 0 ;
31995 int val2 ;
31996 int ecode2 = 0 ;
31997 PyObject * obj0 = 0 ;
31998 PyObject * obj1 = 0 ;
31999 char * kwnames[] = {
32000 (char *) "self",(char *) "dir", NULL
32001 };
32002
32003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32005 if (!SWIG_IsOK(res1)) {
32006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32007 }
32008 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32009 if (obj1) {
32010 ecode2 = SWIG_AsVal_int(obj1, &val2);
32011 if (!SWIG_IsOK(ecode2)) {
32012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32013 }
32014 arg2 = static_cast< wxDataObject::Direction >(val2);
32015 }
32016 {
32017 PyThreadState* __tstate = wxPyBeginAllowThreads();
32018 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32019 wxPyEndAllowThreads(__tstate);
32020 if (PyErr_Occurred()) SWIG_fail;
32021 }
32022 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32023 return resultobj;
32024 fail:
32025 return NULL;
32026 }
32027
32028
32029 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32030 PyObject *resultobj = 0;
32031 wxDataObject *arg1 = (wxDataObject *) 0 ;
32032 wxDataFormat *arg2 = 0 ;
32033 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32034 bool result;
32035 void *argp1 = 0 ;
32036 int res1 = 0 ;
32037 void *argp2 = 0 ;
32038 int res2 = 0 ;
32039 int val3 ;
32040 int ecode3 = 0 ;
32041 PyObject * obj0 = 0 ;
32042 PyObject * obj1 = 0 ;
32043 PyObject * obj2 = 0 ;
32044 char * kwnames[] = {
32045 (char *) "self",(char *) "format",(char *) "dir", NULL
32046 };
32047
32048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32050 if (!SWIG_IsOK(res1)) {
32051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32052 }
32053 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32054 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32055 if (!SWIG_IsOK(res2)) {
32056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32057 }
32058 if (!argp2) {
32059 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32060 }
32061 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32062 if (obj2) {
32063 ecode3 = SWIG_AsVal_int(obj2, &val3);
32064 if (!SWIG_IsOK(ecode3)) {
32065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32066 }
32067 arg3 = static_cast< wxDataObject::Direction >(val3);
32068 }
32069 {
32070 PyThreadState* __tstate = wxPyBeginAllowThreads();
32071 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32072 wxPyEndAllowThreads(__tstate);
32073 if (PyErr_Occurred()) SWIG_fail;
32074 }
32075 {
32076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32077 }
32078 return resultobj;
32079 fail:
32080 return NULL;
32081 }
32082
32083
32084 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32085 PyObject *resultobj = 0;
32086 wxDataObject *arg1 = (wxDataObject *) 0 ;
32087 wxDataFormat *arg2 = 0 ;
32088 size_t result;
32089 void *argp1 = 0 ;
32090 int res1 = 0 ;
32091 void *argp2 = 0 ;
32092 int res2 = 0 ;
32093 PyObject * obj0 = 0 ;
32094 PyObject * obj1 = 0 ;
32095 char * kwnames[] = {
32096 (char *) "self",(char *) "format", NULL
32097 };
32098
32099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32101 if (!SWIG_IsOK(res1)) {
32102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32103 }
32104 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32105 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32106 if (!SWIG_IsOK(res2)) {
32107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32108 }
32109 if (!argp2) {
32110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32111 }
32112 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32113 {
32114 PyThreadState* __tstate = wxPyBeginAllowThreads();
32115 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32116 wxPyEndAllowThreads(__tstate);
32117 if (PyErr_Occurred()) SWIG_fail;
32118 }
32119 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32120 return resultobj;
32121 fail:
32122 return NULL;
32123 }
32124
32125
32126 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32127 PyObject *resultobj = 0;
32128 wxDataObject *arg1 = (wxDataObject *) 0 ;
32129 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32130 PyObject *result = 0 ;
32131 void *argp1 = 0 ;
32132 int res1 = 0 ;
32133 int val2 ;
32134 int ecode2 = 0 ;
32135 PyObject * obj0 = 0 ;
32136 PyObject * obj1 = 0 ;
32137 char * kwnames[] = {
32138 (char *) "self",(char *) "dir", NULL
32139 };
32140
32141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32143 if (!SWIG_IsOK(res1)) {
32144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32145 }
32146 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32147 if (obj1) {
32148 ecode2 = SWIG_AsVal_int(obj1, &val2);
32149 if (!SWIG_IsOK(ecode2)) {
32150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32151 }
32152 arg2 = static_cast< wxDataObject::Direction >(val2);
32153 }
32154 {
32155 PyThreadState* __tstate = wxPyBeginAllowThreads();
32156 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32157 wxPyEndAllowThreads(__tstate);
32158 if (PyErr_Occurred()) SWIG_fail;
32159 }
32160 resultobj = result;
32161 return resultobj;
32162 fail:
32163 return NULL;
32164 }
32165
32166
32167 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32168 PyObject *resultobj = 0;
32169 wxDataObject *arg1 = (wxDataObject *) 0 ;
32170 wxDataFormat *arg2 = 0 ;
32171 PyObject *result = 0 ;
32172 void *argp1 = 0 ;
32173 int res1 = 0 ;
32174 void *argp2 = 0 ;
32175 int res2 = 0 ;
32176 PyObject * obj0 = 0 ;
32177 PyObject * obj1 = 0 ;
32178 char * kwnames[] = {
32179 (char *) "self",(char *) "format", NULL
32180 };
32181
32182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32184 if (!SWIG_IsOK(res1)) {
32185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32186 }
32187 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32188 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32189 if (!SWIG_IsOK(res2)) {
32190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32191 }
32192 if (!argp2) {
32193 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32194 }
32195 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32196 {
32197 PyThreadState* __tstate = wxPyBeginAllowThreads();
32198 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32199 wxPyEndAllowThreads(__tstate);
32200 if (PyErr_Occurred()) SWIG_fail;
32201 }
32202 resultobj = result;
32203 return resultobj;
32204 fail:
32205 return NULL;
32206 }
32207
32208
32209 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32210 PyObject *resultobj = 0;
32211 wxDataObject *arg1 = (wxDataObject *) 0 ;
32212 wxDataFormat *arg2 = 0 ;
32213 PyObject *arg3 = (PyObject *) 0 ;
32214 bool result;
32215 void *argp1 = 0 ;
32216 int res1 = 0 ;
32217 void *argp2 = 0 ;
32218 int res2 = 0 ;
32219 PyObject * obj0 = 0 ;
32220 PyObject * obj1 = 0 ;
32221 PyObject * obj2 = 0 ;
32222 char * kwnames[] = {
32223 (char *) "self",(char *) "format",(char *) "data", NULL
32224 };
32225
32226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32228 if (!SWIG_IsOK(res1)) {
32229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32230 }
32231 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32232 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32233 if (!SWIG_IsOK(res2)) {
32234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32235 }
32236 if (!argp2) {
32237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32238 }
32239 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32240 arg3 = obj2;
32241 {
32242 PyThreadState* __tstate = wxPyBeginAllowThreads();
32243 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32244 wxPyEndAllowThreads(__tstate);
32245 if (PyErr_Occurred()) SWIG_fail;
32246 }
32247 {
32248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32249 }
32250 return resultobj;
32251 fail:
32252 return NULL;
32253 }
32254
32255
32256 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32257 PyObject *obj;
32258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32259 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32260 return SWIG_Py_Void();
32261 }
32262
32263 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32264 PyObject *resultobj = 0;
32265 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32266 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32267 wxDataObjectSimple *result = 0 ;
32268 void *argp1 = 0 ;
32269 int res1 = 0 ;
32270 PyObject * obj0 = 0 ;
32271 char * kwnames[] = {
32272 (char *) "format", NULL
32273 };
32274
32275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32276 if (obj0) {
32277 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32278 if (!SWIG_IsOK(res1)) {
32279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32280 }
32281 if (!argp1) {
32282 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32283 }
32284 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32285 }
32286 {
32287 PyThreadState* __tstate = wxPyBeginAllowThreads();
32288 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32289 wxPyEndAllowThreads(__tstate);
32290 if (PyErr_Occurred()) SWIG_fail;
32291 }
32292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32293 return resultobj;
32294 fail:
32295 return NULL;
32296 }
32297
32298
32299 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32300 PyObject *resultobj = 0;
32301 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32302 wxDataFormat *result = 0 ;
32303 void *argp1 = 0 ;
32304 int res1 = 0 ;
32305 PyObject *swig_obj[1] ;
32306
32307 if (!args) SWIG_fail;
32308 swig_obj[0] = args;
32309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32310 if (!SWIG_IsOK(res1)) {
32311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32312 }
32313 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32314 {
32315 PyThreadState* __tstate = wxPyBeginAllowThreads();
32316 {
32317 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32318 result = (wxDataFormat *) &_result_ref;
32319 }
32320 wxPyEndAllowThreads(__tstate);
32321 if (PyErr_Occurred()) SWIG_fail;
32322 }
32323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32324 return resultobj;
32325 fail:
32326 return NULL;
32327 }
32328
32329
32330 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32331 PyObject *resultobj = 0;
32332 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32333 wxDataFormat *arg2 = 0 ;
32334 void *argp1 = 0 ;
32335 int res1 = 0 ;
32336 void *argp2 = 0 ;
32337 int res2 = 0 ;
32338 PyObject * obj0 = 0 ;
32339 PyObject * obj1 = 0 ;
32340 char * kwnames[] = {
32341 (char *) "self",(char *) "format", NULL
32342 };
32343
32344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32346 if (!SWIG_IsOK(res1)) {
32347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32348 }
32349 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32350 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32351 if (!SWIG_IsOK(res2)) {
32352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32353 }
32354 if (!argp2) {
32355 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32356 }
32357 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32358 {
32359 PyThreadState* __tstate = wxPyBeginAllowThreads();
32360 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32361 wxPyEndAllowThreads(__tstate);
32362 if (PyErr_Occurred()) SWIG_fail;
32363 }
32364 resultobj = SWIG_Py_Void();
32365 return resultobj;
32366 fail:
32367 return NULL;
32368 }
32369
32370
32371 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32372 PyObject *resultobj = 0;
32373 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32374 size_t result;
32375 void *argp1 = 0 ;
32376 int res1 = 0 ;
32377 PyObject *swig_obj[1] ;
32378
32379 if (!args) SWIG_fail;
32380 swig_obj[0] = args;
32381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32382 if (!SWIG_IsOK(res1)) {
32383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32384 }
32385 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32386 {
32387 PyThreadState* __tstate = wxPyBeginAllowThreads();
32388 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32389 wxPyEndAllowThreads(__tstate);
32390 if (PyErr_Occurred()) SWIG_fail;
32391 }
32392 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32393 return resultobj;
32394 fail:
32395 return NULL;
32396 }
32397
32398
32399 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32400 PyObject *resultobj = 0;
32401 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32402 PyObject *result = 0 ;
32403 void *argp1 = 0 ;
32404 int res1 = 0 ;
32405 PyObject *swig_obj[1] ;
32406
32407 if (!args) SWIG_fail;
32408 swig_obj[0] = args;
32409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32410 if (!SWIG_IsOK(res1)) {
32411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32412 }
32413 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32414 {
32415 PyThreadState* __tstate = wxPyBeginAllowThreads();
32416 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32417 wxPyEndAllowThreads(__tstate);
32418 if (PyErr_Occurred()) SWIG_fail;
32419 }
32420 resultobj = result;
32421 return resultobj;
32422 fail:
32423 return NULL;
32424 }
32425
32426
32427 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32428 PyObject *resultobj = 0;
32429 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32430 PyObject *arg2 = (PyObject *) 0 ;
32431 bool result;
32432 void *argp1 = 0 ;
32433 int res1 = 0 ;
32434 PyObject * obj0 = 0 ;
32435 PyObject * obj1 = 0 ;
32436 char * kwnames[] = {
32437 (char *) "self",(char *) "data", NULL
32438 };
32439
32440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32442 if (!SWIG_IsOK(res1)) {
32443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32444 }
32445 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32446 arg2 = obj1;
32447 {
32448 PyThreadState* __tstate = wxPyBeginAllowThreads();
32449 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32450 wxPyEndAllowThreads(__tstate);
32451 if (PyErr_Occurred()) SWIG_fail;
32452 }
32453 {
32454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32455 }
32456 return resultobj;
32457 fail:
32458 return NULL;
32459 }
32460
32461
32462 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32463 PyObject *obj;
32464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32465 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32466 return SWIG_Py_Void();
32467 }
32468
32469 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32470 return SWIG_Python_InitShadowInstance(args);
32471 }
32472
32473 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32474 PyObject *resultobj = 0;
32475 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32476 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32477 wxPyDataObjectSimple *result = 0 ;
32478 void *argp1 = 0 ;
32479 int res1 = 0 ;
32480 PyObject * obj0 = 0 ;
32481 char * kwnames[] = {
32482 (char *) "format", NULL
32483 };
32484
32485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32486 if (obj0) {
32487 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32488 if (!SWIG_IsOK(res1)) {
32489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32490 }
32491 if (!argp1) {
32492 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32493 }
32494 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32495 }
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32499 wxPyEndAllowThreads(__tstate);
32500 if (PyErr_Occurred()) SWIG_fail;
32501 }
32502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32503 return resultobj;
32504 fail:
32505 return NULL;
32506 }
32507
32508
32509 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32510 PyObject *resultobj = 0;
32511 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32512 PyObject *arg2 = (PyObject *) 0 ;
32513 PyObject *arg3 = (PyObject *) 0 ;
32514 void *argp1 = 0 ;
32515 int res1 = 0 ;
32516 PyObject * obj0 = 0 ;
32517 PyObject * obj1 = 0 ;
32518 PyObject * obj2 = 0 ;
32519 char * kwnames[] = {
32520 (char *) "self",(char *) "self",(char *) "_class", NULL
32521 };
32522
32523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32525 if (!SWIG_IsOK(res1)) {
32526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32527 }
32528 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32529 arg2 = obj1;
32530 arg3 = obj2;
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 (arg1)->_setCallbackInfo(arg2,arg3);
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 resultobj = SWIG_Py_Void();
32538 return resultobj;
32539 fail:
32540 return NULL;
32541 }
32542
32543
32544 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32545 PyObject *obj;
32546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32547 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32548 return SWIG_Py_Void();
32549 }
32550
32551 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32552 return SWIG_Python_InitShadowInstance(args);
32553 }
32554
32555 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32556 PyObject *resultobj = 0;
32557 wxDataObjectComposite *result = 0 ;
32558
32559 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32563 wxPyEndAllowThreads(__tstate);
32564 if (PyErr_Occurred()) SWIG_fail;
32565 }
32566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32567 return resultobj;
32568 fail:
32569 return NULL;
32570 }
32571
32572
32573 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32574 PyObject *resultobj = 0;
32575 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32576 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32577 bool arg3 = (bool) false ;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 int res2 = 0 ;
32581 bool val3 ;
32582 int ecode3 = 0 ;
32583 PyObject * obj0 = 0 ;
32584 PyObject * obj1 = 0 ;
32585 PyObject * obj2 = 0 ;
32586 char * kwnames[] = {
32587 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32588 };
32589
32590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32592 if (!SWIG_IsOK(res1)) {
32593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32594 }
32595 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32596 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32597 if (!SWIG_IsOK(res2)) {
32598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32599 }
32600 if (obj2) {
32601 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32602 if (!SWIG_IsOK(ecode3)) {
32603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32604 }
32605 arg3 = static_cast< bool >(val3);
32606 }
32607 {
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 (arg1)->Add(arg2,arg3);
32610 wxPyEndAllowThreads(__tstate);
32611 if (PyErr_Occurred()) SWIG_fail;
32612 }
32613 resultobj = SWIG_Py_Void();
32614 return resultobj;
32615 fail:
32616 return NULL;
32617 }
32618
32619
32620 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32621 PyObject *resultobj = 0;
32622 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32623 SwigValueWrapper<wxDataFormat > result;
32624 void *argp1 = 0 ;
32625 int res1 = 0 ;
32626 PyObject *swig_obj[1] ;
32627
32628 if (!args) SWIG_fail;
32629 swig_obj[0] = args;
32630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32631 if (!SWIG_IsOK(res1)) {
32632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32633 }
32634 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32635 {
32636 PyThreadState* __tstate = wxPyBeginAllowThreads();
32637 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32638 wxPyEndAllowThreads(__tstate);
32639 if (PyErr_Occurred()) SWIG_fail;
32640 }
32641 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32642 return resultobj;
32643 fail:
32644 return NULL;
32645 }
32646
32647
32648 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32649 PyObject *obj;
32650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32651 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32652 return SWIG_Py_Void();
32653 }
32654
32655 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32656 return SWIG_Python_InitShadowInstance(args);
32657 }
32658
32659 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32660 PyObject *resultobj = 0;
32661 wxString const &arg1_defvalue = wxPyEmptyString ;
32662 wxString *arg1 = (wxString *) &arg1_defvalue ;
32663 wxTextDataObject *result = 0 ;
32664 bool temp1 = false ;
32665 PyObject * obj0 = 0 ;
32666 char * kwnames[] = {
32667 (char *) "text", NULL
32668 };
32669
32670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32671 if (obj0) {
32672 {
32673 arg1 = wxString_in_helper(obj0);
32674 if (arg1 == NULL) SWIG_fail;
32675 temp1 = true;
32676 }
32677 }
32678 {
32679 PyThreadState* __tstate = wxPyBeginAllowThreads();
32680 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32681 wxPyEndAllowThreads(__tstate);
32682 if (PyErr_Occurred()) SWIG_fail;
32683 }
32684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32685 {
32686 if (temp1)
32687 delete arg1;
32688 }
32689 return resultobj;
32690 fail:
32691 {
32692 if (temp1)
32693 delete arg1;
32694 }
32695 return NULL;
32696 }
32697
32698
32699 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32700 PyObject *resultobj = 0;
32701 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32702 size_t result;
32703 void *argp1 = 0 ;
32704 int res1 = 0 ;
32705 PyObject *swig_obj[1] ;
32706
32707 if (!args) SWIG_fail;
32708 swig_obj[0] = args;
32709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32710 if (!SWIG_IsOK(res1)) {
32711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32712 }
32713 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32714 {
32715 PyThreadState* __tstate = wxPyBeginAllowThreads();
32716 result = (size_t)(arg1)->GetTextLength();
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32728 PyObject *resultobj = 0;
32729 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32730 wxString result;
32731 void *argp1 = 0 ;
32732 int res1 = 0 ;
32733 PyObject *swig_obj[1] ;
32734
32735 if (!args) SWIG_fail;
32736 swig_obj[0] = args;
32737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32738 if (!SWIG_IsOK(res1)) {
32739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32740 }
32741 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32742 {
32743 PyThreadState* __tstate = wxPyBeginAllowThreads();
32744 result = (arg1)->GetText();
32745 wxPyEndAllowThreads(__tstate);
32746 if (PyErr_Occurred()) SWIG_fail;
32747 }
32748 {
32749 #if wxUSE_UNICODE
32750 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32751 #else
32752 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32753 #endif
32754 }
32755 return resultobj;
32756 fail:
32757 return NULL;
32758 }
32759
32760
32761 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32762 PyObject *resultobj = 0;
32763 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32764 wxString *arg2 = 0 ;
32765 void *argp1 = 0 ;
32766 int res1 = 0 ;
32767 bool temp2 = false ;
32768 PyObject * obj0 = 0 ;
32769 PyObject * obj1 = 0 ;
32770 char * kwnames[] = {
32771 (char *) "self",(char *) "text", NULL
32772 };
32773
32774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32776 if (!SWIG_IsOK(res1)) {
32777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32778 }
32779 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32780 {
32781 arg2 = wxString_in_helper(obj1);
32782 if (arg2 == NULL) SWIG_fail;
32783 temp2 = true;
32784 }
32785 {
32786 PyThreadState* __tstate = wxPyBeginAllowThreads();
32787 (arg1)->SetText((wxString const &)*arg2);
32788 wxPyEndAllowThreads(__tstate);
32789 if (PyErr_Occurred()) SWIG_fail;
32790 }
32791 resultobj = SWIG_Py_Void();
32792 {
32793 if (temp2)
32794 delete arg2;
32795 }
32796 return resultobj;
32797 fail:
32798 {
32799 if (temp2)
32800 delete arg2;
32801 }
32802 return NULL;
32803 }
32804
32805
32806 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32807 PyObject *obj;
32808 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32809 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32810 return SWIG_Py_Void();
32811 }
32812
32813 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32814 return SWIG_Python_InitShadowInstance(args);
32815 }
32816
32817 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32818 PyObject *resultobj = 0;
32819 wxString const &arg1_defvalue = wxPyEmptyString ;
32820 wxString *arg1 = (wxString *) &arg1_defvalue ;
32821 wxPyTextDataObject *result = 0 ;
32822 bool temp1 = false ;
32823 PyObject * obj0 = 0 ;
32824 char * kwnames[] = {
32825 (char *) "text", NULL
32826 };
32827
32828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32829 if (obj0) {
32830 {
32831 arg1 = wxString_in_helper(obj0);
32832 if (arg1 == NULL) SWIG_fail;
32833 temp1 = true;
32834 }
32835 }
32836 {
32837 PyThreadState* __tstate = wxPyBeginAllowThreads();
32838 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32839 wxPyEndAllowThreads(__tstate);
32840 if (PyErr_Occurred()) SWIG_fail;
32841 }
32842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32843 {
32844 if (temp1)
32845 delete arg1;
32846 }
32847 return resultobj;
32848 fail:
32849 {
32850 if (temp1)
32851 delete arg1;
32852 }
32853 return NULL;
32854 }
32855
32856
32857 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32858 PyObject *resultobj = 0;
32859 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32860 PyObject *arg2 = (PyObject *) 0 ;
32861 PyObject *arg3 = (PyObject *) 0 ;
32862 void *argp1 = 0 ;
32863 int res1 = 0 ;
32864 PyObject * obj0 = 0 ;
32865 PyObject * obj1 = 0 ;
32866 PyObject * obj2 = 0 ;
32867 char * kwnames[] = {
32868 (char *) "self",(char *) "self",(char *) "_class", NULL
32869 };
32870
32871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32873 if (!SWIG_IsOK(res1)) {
32874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32875 }
32876 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32877 arg2 = obj1;
32878 arg3 = obj2;
32879 {
32880 PyThreadState* __tstate = wxPyBeginAllowThreads();
32881 (arg1)->_setCallbackInfo(arg2,arg3);
32882 wxPyEndAllowThreads(__tstate);
32883 if (PyErr_Occurred()) SWIG_fail;
32884 }
32885 resultobj = SWIG_Py_Void();
32886 return resultobj;
32887 fail:
32888 return NULL;
32889 }
32890
32891
32892 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32893 PyObject *obj;
32894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32895 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32896 return SWIG_Py_Void();
32897 }
32898
32899 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32900 return SWIG_Python_InitShadowInstance(args);
32901 }
32902
32903 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32904 PyObject *resultobj = 0;
32905 wxBitmap const &arg1_defvalue = wxNullBitmap ;
32906 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
32907 wxBitmapDataObject *result = 0 ;
32908 void *argp1 = 0 ;
32909 int res1 = 0 ;
32910 PyObject * obj0 = 0 ;
32911 char * kwnames[] = {
32912 (char *) "bitmap", NULL
32913 };
32914
32915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
32916 if (obj0) {
32917 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
32918 if (!SWIG_IsOK(res1)) {
32919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32920 }
32921 if (!argp1) {
32922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
32923 }
32924 arg1 = reinterpret_cast< wxBitmap * >(argp1);
32925 }
32926 {
32927 PyThreadState* __tstate = wxPyBeginAllowThreads();
32928 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
32929 wxPyEndAllowThreads(__tstate);
32930 if (PyErr_Occurred()) SWIG_fail;
32931 }
32932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
32933 return resultobj;
32934 fail:
32935 return NULL;
32936 }
32937
32938
32939 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32940 PyObject *resultobj = 0;
32941 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32942 wxBitmap result;
32943 void *argp1 = 0 ;
32944 int res1 = 0 ;
32945 PyObject *swig_obj[1] ;
32946
32947 if (!args) SWIG_fail;
32948 swig_obj[0] = args;
32949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32950 if (!SWIG_IsOK(res1)) {
32951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
32952 }
32953 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32954 {
32955 PyThreadState* __tstate = wxPyBeginAllowThreads();
32956 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
32957 wxPyEndAllowThreads(__tstate);
32958 if (PyErr_Occurred()) SWIG_fail;
32959 }
32960 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
32961 return resultobj;
32962 fail:
32963 return NULL;
32964 }
32965
32966
32967 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32968 PyObject *resultobj = 0;
32969 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
32970 wxBitmap *arg2 = 0 ;
32971 void *argp1 = 0 ;
32972 int res1 = 0 ;
32973 void *argp2 = 0 ;
32974 int res2 = 0 ;
32975 PyObject * obj0 = 0 ;
32976 PyObject * obj1 = 0 ;
32977 char * kwnames[] = {
32978 (char *) "self",(char *) "bitmap", NULL
32979 };
32980
32981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
32982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
32983 if (!SWIG_IsOK(res1)) {
32984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
32985 }
32986 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
32987 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
32988 if (!SWIG_IsOK(res2)) {
32989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32990 }
32991 if (!argp2) {
32992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
32993 }
32994 arg2 = reinterpret_cast< wxBitmap * >(argp2);
32995 {
32996 PyThreadState* __tstate = wxPyBeginAllowThreads();
32997 (arg1)->SetBitmap((wxBitmap const &)*arg2);
32998 wxPyEndAllowThreads(__tstate);
32999 if (PyErr_Occurred()) SWIG_fail;
33000 }
33001 resultobj = SWIG_Py_Void();
33002 return resultobj;
33003 fail:
33004 return NULL;
33005 }
33006
33007
33008 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33009 PyObject *obj;
33010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33011 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33012 return SWIG_Py_Void();
33013 }
33014
33015 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33016 return SWIG_Python_InitShadowInstance(args);
33017 }
33018
33019 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33020 PyObject *resultobj = 0;
33021 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33022 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33023 wxPyBitmapDataObject *result = 0 ;
33024 void *argp1 = 0 ;
33025 int res1 = 0 ;
33026 PyObject * obj0 = 0 ;
33027 char * kwnames[] = {
33028 (char *) "bitmap", NULL
33029 };
33030
33031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33032 if (obj0) {
33033 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33034 if (!SWIG_IsOK(res1)) {
33035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33036 }
33037 if (!argp1) {
33038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33039 }
33040 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33041 }
33042 {
33043 PyThreadState* __tstate = wxPyBeginAllowThreads();
33044 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33045 wxPyEndAllowThreads(__tstate);
33046 if (PyErr_Occurred()) SWIG_fail;
33047 }
33048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33049 return resultobj;
33050 fail:
33051 return NULL;
33052 }
33053
33054
33055 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33056 PyObject *resultobj = 0;
33057 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33058 PyObject *arg2 = (PyObject *) 0 ;
33059 PyObject *arg3 = (PyObject *) 0 ;
33060 void *argp1 = 0 ;
33061 int res1 = 0 ;
33062 PyObject * obj0 = 0 ;
33063 PyObject * obj1 = 0 ;
33064 PyObject * obj2 = 0 ;
33065 char * kwnames[] = {
33066 (char *) "self",(char *) "self",(char *) "_class", NULL
33067 };
33068
33069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33071 if (!SWIG_IsOK(res1)) {
33072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33073 }
33074 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33075 arg2 = obj1;
33076 arg3 = obj2;
33077 {
33078 PyThreadState* __tstate = wxPyBeginAllowThreads();
33079 (arg1)->_setCallbackInfo(arg2,arg3);
33080 wxPyEndAllowThreads(__tstate);
33081 if (PyErr_Occurred()) SWIG_fail;
33082 }
33083 resultobj = SWIG_Py_Void();
33084 return resultobj;
33085 fail:
33086 return NULL;
33087 }
33088
33089
33090 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33091 PyObject *obj;
33092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33093 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33094 return SWIG_Py_Void();
33095 }
33096
33097 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33098 return SWIG_Python_InitShadowInstance(args);
33099 }
33100
33101 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33102 PyObject *resultobj = 0;
33103 wxFileDataObject *result = 0 ;
33104
33105 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 result = (wxFileDataObject *)new wxFileDataObject();
33109 wxPyEndAllowThreads(__tstate);
33110 if (PyErr_Occurred()) SWIG_fail;
33111 }
33112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33113 return resultobj;
33114 fail:
33115 return NULL;
33116 }
33117
33118
33119 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33120 PyObject *resultobj = 0;
33121 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33122 wxArrayString *result = 0 ;
33123 void *argp1 = 0 ;
33124 int res1 = 0 ;
33125 PyObject *swig_obj[1] ;
33126
33127 if (!args) SWIG_fail;
33128 swig_obj[0] = args;
33129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33130 if (!SWIG_IsOK(res1)) {
33131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33132 }
33133 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 {
33137 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33138 result = (wxArrayString *) &_result_ref;
33139 }
33140 wxPyEndAllowThreads(__tstate);
33141 if (PyErr_Occurred()) SWIG_fail;
33142 }
33143 {
33144 resultobj = wxArrayString2PyList_helper(*result);
33145 }
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33153 PyObject *resultobj = 0;
33154 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33155 wxString *arg2 = 0 ;
33156 void *argp1 = 0 ;
33157 int res1 = 0 ;
33158 bool temp2 = false ;
33159 PyObject * obj0 = 0 ;
33160 PyObject * obj1 = 0 ;
33161 char * kwnames[] = {
33162 (char *) "self",(char *) "filename", NULL
33163 };
33164
33165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33167 if (!SWIG_IsOK(res1)) {
33168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33169 }
33170 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33171 {
33172 arg2 = wxString_in_helper(obj1);
33173 if (arg2 == NULL) SWIG_fail;
33174 temp2 = true;
33175 }
33176 {
33177 PyThreadState* __tstate = wxPyBeginAllowThreads();
33178 (arg1)->AddFile((wxString const &)*arg2);
33179 wxPyEndAllowThreads(__tstate);
33180 if (PyErr_Occurred()) SWIG_fail;
33181 }
33182 resultobj = SWIG_Py_Void();
33183 {
33184 if (temp2)
33185 delete arg2;
33186 }
33187 return resultobj;
33188 fail:
33189 {
33190 if (temp2)
33191 delete arg2;
33192 }
33193 return NULL;
33194 }
33195
33196
33197 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33198 PyObject *obj;
33199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33200 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33201 return SWIG_Py_Void();
33202 }
33203
33204 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33205 return SWIG_Python_InitShadowInstance(args);
33206 }
33207
33208 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33209 PyObject *resultobj = 0;
33210 wxDataFormat *arg1 = 0 ;
33211 wxCustomDataObject *result = 0 ;
33212 void *argp1 = 0 ;
33213 int res1 = 0 ;
33214
33215 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33217 if (!SWIG_IsOK(res1)) {
33218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33219 }
33220 if (!argp1) {
33221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33222 }
33223 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33224 {
33225 PyThreadState* __tstate = wxPyBeginAllowThreads();
33226 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33227 wxPyEndAllowThreads(__tstate);
33228 if (PyErr_Occurred()) SWIG_fail;
33229 }
33230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33231 return resultobj;
33232 fail:
33233 return NULL;
33234 }
33235
33236
33237 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33238 PyObject *resultobj = 0;
33239 wxString *arg1 = 0 ;
33240 wxCustomDataObject *result = 0 ;
33241 bool temp1 = false ;
33242
33243 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33244 {
33245 arg1 = wxString_in_helper(swig_obj[0]);
33246 if (arg1 == NULL) SWIG_fail;
33247 temp1 = true;
33248 }
33249 {
33250 PyThreadState* __tstate = wxPyBeginAllowThreads();
33251 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33252 wxPyEndAllowThreads(__tstate);
33253 if (PyErr_Occurred()) SWIG_fail;
33254 }
33255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33256 {
33257 if (temp1)
33258 delete arg1;
33259 }
33260 return resultobj;
33261 fail:
33262 {
33263 if (temp1)
33264 delete arg1;
33265 }
33266 return NULL;
33267 }
33268
33269
33270 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33271 PyObject *resultobj = 0;
33272 wxCustomDataObject *result = 0 ;
33273
33274 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33275 {
33276 PyThreadState* __tstate = wxPyBeginAllowThreads();
33277 result = (wxCustomDataObject *)new wxCustomDataObject();
33278 wxPyEndAllowThreads(__tstate);
33279 if (PyErr_Occurred()) SWIG_fail;
33280 }
33281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33282 return resultobj;
33283 fail:
33284 return NULL;
33285 }
33286
33287
33288 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33289 int argc;
33290 PyObject *argv[2];
33291
33292 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33293 --argc;
33294 if (argc == 0) {
33295 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33296 }
33297 if (argc == 1) {
33298 int _v = 0;
33299 {
33300 {
33301 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33302 }
33303 }
33304 if (!_v) goto check_2;
33305 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33306 }
33307 check_2:
33308
33309 if (argc == 1) {
33310 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33311 }
33312
33313 fail:
33314 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33315 return NULL;
33316 }
33317
33318
33319 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33320 PyObject *resultobj = 0;
33321 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33322 PyObject *arg2 = (PyObject *) 0 ;
33323 bool result;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 PyObject * obj0 = 0 ;
33327 PyObject * obj1 = 0 ;
33328 char * kwnames[] = {
33329 (char *) "self",(char *) "data", NULL
33330 };
33331
33332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33334 if (!SWIG_IsOK(res1)) {
33335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33336 }
33337 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33338 arg2 = obj1;
33339 {
33340 PyThreadState* __tstate = wxPyBeginAllowThreads();
33341 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33342 wxPyEndAllowThreads(__tstate);
33343 if (PyErr_Occurred()) SWIG_fail;
33344 }
33345 {
33346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33347 }
33348 return resultobj;
33349 fail:
33350 return NULL;
33351 }
33352
33353
33354 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33355 PyObject *resultobj = 0;
33356 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33357 size_t result;
33358 void *argp1 = 0 ;
33359 int res1 = 0 ;
33360 PyObject *swig_obj[1] ;
33361
33362 if (!args) SWIG_fail;
33363 swig_obj[0] = args;
33364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33365 if (!SWIG_IsOK(res1)) {
33366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33367 }
33368 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33369 {
33370 PyThreadState* __tstate = wxPyBeginAllowThreads();
33371 result = (size_t)(arg1)->GetSize();
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33383 PyObject *resultobj = 0;
33384 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33385 PyObject *result = 0 ;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 PyObject *swig_obj[1] ;
33389
33390 if (!args) SWIG_fail;
33391 swig_obj[0] = args;
33392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33393 if (!SWIG_IsOK(res1)) {
33394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33395 }
33396 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33397 {
33398 PyThreadState* __tstate = wxPyBeginAllowThreads();
33399 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33400 wxPyEndAllowThreads(__tstate);
33401 if (PyErr_Occurred()) SWIG_fail;
33402 }
33403 resultobj = result;
33404 return resultobj;
33405 fail:
33406 return NULL;
33407 }
33408
33409
33410 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33411 PyObject *obj;
33412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33413 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33414 return SWIG_Py_Void();
33415 }
33416
33417 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33418 return SWIG_Python_InitShadowInstance(args);
33419 }
33420
33421 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33422 PyObject *resultobj = 0;
33423 wxString const &arg1_defvalue = wxPyEmptyString ;
33424 wxString *arg1 = (wxString *) &arg1_defvalue ;
33425 wxURLDataObject *result = 0 ;
33426 bool temp1 = false ;
33427 PyObject * obj0 = 0 ;
33428 char * kwnames[] = {
33429 (char *) "url", NULL
33430 };
33431
33432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33433 if (obj0) {
33434 {
33435 arg1 = wxString_in_helper(obj0);
33436 if (arg1 == NULL) SWIG_fail;
33437 temp1 = true;
33438 }
33439 }
33440 {
33441 PyThreadState* __tstate = wxPyBeginAllowThreads();
33442 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33443 wxPyEndAllowThreads(__tstate);
33444 if (PyErr_Occurred()) SWIG_fail;
33445 }
33446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33447 {
33448 if (temp1)
33449 delete arg1;
33450 }
33451 return resultobj;
33452 fail:
33453 {
33454 if (temp1)
33455 delete arg1;
33456 }
33457 return NULL;
33458 }
33459
33460
33461 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33462 PyObject *resultobj = 0;
33463 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33464 wxString result;
33465 void *argp1 = 0 ;
33466 int res1 = 0 ;
33467 PyObject *swig_obj[1] ;
33468
33469 if (!args) SWIG_fail;
33470 swig_obj[0] = args;
33471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33472 if (!SWIG_IsOK(res1)) {
33473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33474 }
33475 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33476 {
33477 PyThreadState* __tstate = wxPyBeginAllowThreads();
33478 result = (arg1)->GetURL();
33479 wxPyEndAllowThreads(__tstate);
33480 if (PyErr_Occurred()) SWIG_fail;
33481 }
33482 {
33483 #if wxUSE_UNICODE
33484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33485 #else
33486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33487 #endif
33488 }
33489 return resultobj;
33490 fail:
33491 return NULL;
33492 }
33493
33494
33495 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33496 PyObject *resultobj = 0;
33497 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33498 wxString *arg2 = 0 ;
33499 void *argp1 = 0 ;
33500 int res1 = 0 ;
33501 bool temp2 = false ;
33502 PyObject * obj0 = 0 ;
33503 PyObject * obj1 = 0 ;
33504 char * kwnames[] = {
33505 (char *) "self",(char *) "url", NULL
33506 };
33507
33508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33510 if (!SWIG_IsOK(res1)) {
33511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33512 }
33513 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33514 {
33515 arg2 = wxString_in_helper(obj1);
33516 if (arg2 == NULL) SWIG_fail;
33517 temp2 = true;
33518 }
33519 {
33520 PyThreadState* __tstate = wxPyBeginAllowThreads();
33521 (arg1)->SetURL((wxString const &)*arg2);
33522 wxPyEndAllowThreads(__tstate);
33523 if (PyErr_Occurred()) SWIG_fail;
33524 }
33525 resultobj = SWIG_Py_Void();
33526 {
33527 if (temp2)
33528 delete arg2;
33529 }
33530 return resultobj;
33531 fail:
33532 {
33533 if (temp2)
33534 delete arg2;
33535 }
33536 return NULL;
33537 }
33538
33539
33540 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33541 PyObject *obj;
33542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33543 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33544 return SWIG_Py_Void();
33545 }
33546
33547 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33548 return SWIG_Python_InitShadowInstance(args);
33549 }
33550
33551 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33552 PyObject *resultobj = 0;
33553 wxMetafileDataObject *result = 0 ;
33554
33555 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33556 {
33557 PyThreadState* __tstate = wxPyBeginAllowThreads();
33558 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33559 wxPyEndAllowThreads(__tstate);
33560 if (PyErr_Occurred()) SWIG_fail;
33561 }
33562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33563 return resultobj;
33564 fail:
33565 return NULL;
33566 }
33567
33568
33569 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33570 PyObject *resultobj = 0;
33571 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33572 wxMetafile *arg2 = 0 ;
33573 void *argp1 = 0 ;
33574 int res1 = 0 ;
33575 void *argp2 = 0 ;
33576 int res2 = 0 ;
33577 PyObject * obj0 = 0 ;
33578 PyObject * obj1 = 0 ;
33579 char * kwnames[] = {
33580 (char *) "self",(char *) "metafile", NULL
33581 };
33582
33583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
33584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33585 if (!SWIG_IsOK(res1)) {
33586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
33587 }
33588 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33589 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
33590 if (!SWIG_IsOK(res2)) {
33591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33592 }
33593 if (!argp2) {
33594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
33595 }
33596 arg2 = reinterpret_cast< wxMetafile * >(argp2);
33597 {
33598 PyThreadState* __tstate = wxPyBeginAllowThreads();
33599 (arg1)->SetMetafile((wxMetafile const &)*arg2);
33600 wxPyEndAllowThreads(__tstate);
33601 if (PyErr_Occurred()) SWIG_fail;
33602 }
33603 resultobj = SWIG_Py_Void();
33604 return resultobj;
33605 fail:
33606 return NULL;
33607 }
33608
33609
33610 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33611 PyObject *resultobj = 0;
33612 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
33613 wxMetafile result;
33614 void *argp1 = 0 ;
33615 int res1 = 0 ;
33616 PyObject *swig_obj[1] ;
33617
33618 if (!args) SWIG_fail;
33619 swig_obj[0] = args;
33620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
33621 if (!SWIG_IsOK(res1)) {
33622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
33623 }
33624 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
33625 {
33626 PyThreadState* __tstate = wxPyBeginAllowThreads();
33627 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
33628 wxPyEndAllowThreads(__tstate);
33629 if (PyErr_Occurred()) SWIG_fail;
33630 }
33631 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
33632 return resultobj;
33633 fail:
33634 return NULL;
33635 }
33636
33637
33638 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33639 PyObject *obj;
33640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33641 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33642 return SWIG_Py_Void();
33643 }
33644
33645 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33646 return SWIG_Python_InitShadowInstance(args);
33647 }
33648
33649 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33650 PyObject *resultobj = 0;
33651 wxDragResult arg1 ;
33652 bool result;
33653 int val1 ;
33654 int ecode1 = 0 ;
33655 PyObject * obj0 = 0 ;
33656 char * kwnames[] = {
33657 (char *) "res", NULL
33658 };
33659
33660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33661 ecode1 = SWIG_AsVal_int(obj0, &val1);
33662 if (!SWIG_IsOK(ecode1)) {
33663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33664 }
33665 arg1 = static_cast< wxDragResult >(val1);
33666 {
33667 PyThreadState* __tstate = wxPyBeginAllowThreads();
33668 result = (bool)wxIsDragResultOk(arg1);
33669 wxPyEndAllowThreads(__tstate);
33670 if (PyErr_Occurred()) SWIG_fail;
33671 }
33672 {
33673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33674 }
33675 return resultobj;
33676 fail:
33677 return NULL;
33678 }
33679
33680
33681 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33682 PyObject *resultobj = 0;
33683 wxWindow *arg1 = (wxWindow *) 0 ;
33684 wxCursor const &arg2_defvalue = wxNullCursor ;
33685 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
33686 wxCursor const &arg3_defvalue = wxNullCursor ;
33687 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
33688 wxCursor const &arg4_defvalue = wxNullCursor ;
33689 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
33690 wxPyDropSource *result = 0 ;
33691 void *argp1 = 0 ;
33692 int res1 = 0 ;
33693 void *argp2 = 0 ;
33694 int res2 = 0 ;
33695 void *argp3 = 0 ;
33696 int res3 = 0 ;
33697 void *argp4 = 0 ;
33698 int res4 = 0 ;
33699 PyObject * obj0 = 0 ;
33700 PyObject * obj1 = 0 ;
33701 PyObject * obj2 = 0 ;
33702 PyObject * obj3 = 0 ;
33703 char * kwnames[] = {
33704 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33705 };
33706
33707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33709 if (!SWIG_IsOK(res1)) {
33710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33711 }
33712 arg1 = reinterpret_cast< wxWindow * >(argp1);
33713 if (obj1) {
33714 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
33715 if (!SWIG_IsOK(res2)) {
33716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33717 }
33718 if (!argp2) {
33719 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
33720 }
33721 arg2 = reinterpret_cast< wxCursor * >(argp2);
33722 }
33723 if (obj2) {
33724 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33725 if (!SWIG_IsOK(res3)) {
33726 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33727 }
33728 if (!argp3) {
33729 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
33730 }
33731 arg3 = reinterpret_cast< wxCursor * >(argp3);
33732 }
33733 if (obj3) {
33734 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
33735 if (!SWIG_IsOK(res4)) {
33736 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33737 }
33738 if (!argp4) {
33739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
33740 }
33741 arg4 = reinterpret_cast< wxCursor * >(argp4);
33742 }
33743 {
33744 PyThreadState* __tstate = wxPyBeginAllowThreads();
33745 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
33746 wxPyEndAllowThreads(__tstate);
33747 if (PyErr_Occurred()) SWIG_fail;
33748 }
33749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33750 return resultobj;
33751 fail:
33752 return NULL;
33753 }
33754
33755
33756 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33757 PyObject *resultobj = 0;
33758 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33759 PyObject *arg2 = (PyObject *) 0 ;
33760 PyObject *arg3 = (PyObject *) 0 ;
33761 int arg4 ;
33762 void *argp1 = 0 ;
33763 int res1 = 0 ;
33764 int val4 ;
33765 int ecode4 = 0 ;
33766 PyObject * obj0 = 0 ;
33767 PyObject * obj1 = 0 ;
33768 PyObject * obj2 = 0 ;
33769 PyObject * obj3 = 0 ;
33770 char * kwnames[] = {
33771 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33772 };
33773
33774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33776 if (!SWIG_IsOK(res1)) {
33777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33778 }
33779 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33780 arg2 = obj1;
33781 arg3 = obj2;
33782 ecode4 = SWIG_AsVal_int(obj3, &val4);
33783 if (!SWIG_IsOK(ecode4)) {
33784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33785 }
33786 arg4 = static_cast< int >(val4);
33787 {
33788 PyThreadState* __tstate = wxPyBeginAllowThreads();
33789 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33790 wxPyEndAllowThreads(__tstate);
33791 if (PyErr_Occurred()) SWIG_fail;
33792 }
33793 resultobj = SWIG_Py_Void();
33794 return resultobj;
33795 fail:
33796 return NULL;
33797 }
33798
33799
33800 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33801 PyObject *resultobj = 0;
33802 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33803 void *argp1 = 0 ;
33804 int res1 = 0 ;
33805 PyObject *swig_obj[1] ;
33806
33807 if (!args) SWIG_fail;
33808 swig_obj[0] = args;
33809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33810 if (!SWIG_IsOK(res1)) {
33811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33812 }
33813 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33814 {
33815 PyThreadState* __tstate = wxPyBeginAllowThreads();
33816 delete arg1;
33817
33818 wxPyEndAllowThreads(__tstate);
33819 if (PyErr_Occurred()) SWIG_fail;
33820 }
33821 resultobj = SWIG_Py_Void();
33822 return resultobj;
33823 fail:
33824 return NULL;
33825 }
33826
33827
33828 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33829 PyObject *resultobj = 0;
33830 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33831 wxDataObject *arg2 = 0 ;
33832 void *argp1 = 0 ;
33833 int res1 = 0 ;
33834 void *argp2 = 0 ;
33835 int res2 = 0 ;
33836 PyObject * obj0 = 0 ;
33837 PyObject * obj1 = 0 ;
33838 char * kwnames[] = {
33839 (char *) "self",(char *) "data", NULL
33840 };
33841
33842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33844 if (!SWIG_IsOK(res1)) {
33845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33846 }
33847 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33848 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33849 if (!SWIG_IsOK(res2)) {
33850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33851 }
33852 if (!argp2) {
33853 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33854 }
33855 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33856 {
33857 PyThreadState* __tstate = wxPyBeginAllowThreads();
33858 (arg1)->SetData(*arg2);
33859 wxPyEndAllowThreads(__tstate);
33860 if (PyErr_Occurred()) SWIG_fail;
33861 }
33862 resultobj = SWIG_Py_Void();
33863 return resultobj;
33864 fail:
33865 return NULL;
33866 }
33867
33868
33869 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33870 PyObject *resultobj = 0;
33871 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33872 wxDataObject *result = 0 ;
33873 void *argp1 = 0 ;
33874 int res1 = 0 ;
33875 PyObject *swig_obj[1] ;
33876
33877 if (!args) SWIG_fail;
33878 swig_obj[0] = args;
33879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33880 if (!SWIG_IsOK(res1)) {
33881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33882 }
33883 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33884 {
33885 PyThreadState* __tstate = wxPyBeginAllowThreads();
33886 result = (wxDataObject *)(arg1)->GetDataObject();
33887 wxPyEndAllowThreads(__tstate);
33888 if (PyErr_Occurred()) SWIG_fail;
33889 }
33890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33891 return resultobj;
33892 fail:
33893 return NULL;
33894 }
33895
33896
33897 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33898 PyObject *resultobj = 0;
33899 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33900 wxDragResult arg2 ;
33901 wxCursor *arg3 = 0 ;
33902 void *argp1 = 0 ;
33903 int res1 = 0 ;
33904 int val2 ;
33905 int ecode2 = 0 ;
33906 void *argp3 = 0 ;
33907 int res3 = 0 ;
33908 PyObject * obj0 = 0 ;
33909 PyObject * obj1 = 0 ;
33910 PyObject * obj2 = 0 ;
33911 char * kwnames[] = {
33912 (char *) "self",(char *) "res",(char *) "cursor", NULL
33913 };
33914
33915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33917 if (!SWIG_IsOK(res1)) {
33918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33919 }
33920 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33921 ecode2 = SWIG_AsVal_int(obj1, &val2);
33922 if (!SWIG_IsOK(ecode2)) {
33923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33924 }
33925 arg2 = static_cast< wxDragResult >(val2);
33926 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33927 if (!SWIG_IsOK(res3)) {
33928 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33929 }
33930 if (!argp3) {
33931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33932 }
33933 arg3 = reinterpret_cast< wxCursor * >(argp3);
33934 {
33935 PyThreadState* __tstate = wxPyBeginAllowThreads();
33936 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33937 wxPyEndAllowThreads(__tstate);
33938 if (PyErr_Occurred()) SWIG_fail;
33939 }
33940 resultobj = SWIG_Py_Void();
33941 return resultobj;
33942 fail:
33943 return NULL;
33944 }
33945
33946
33947 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33948 PyObject *resultobj = 0;
33949 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33950 int arg2 = (int) wxDrag_CopyOnly ;
33951 wxDragResult result;
33952 void *argp1 = 0 ;
33953 int res1 = 0 ;
33954 int val2 ;
33955 int ecode2 = 0 ;
33956 PyObject * obj0 = 0 ;
33957 PyObject * obj1 = 0 ;
33958 char * kwnames[] = {
33959 (char *) "self",(char *) "flags", NULL
33960 };
33961
33962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33966 }
33967 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33968 if (obj1) {
33969 ecode2 = SWIG_AsVal_int(obj1, &val2);
33970 if (!SWIG_IsOK(ecode2)) {
33971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33972 }
33973 arg2 = static_cast< int >(val2);
33974 }
33975 {
33976 PyThreadState* __tstate = wxPyBeginAllowThreads();
33977 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
33978 wxPyEndAllowThreads(__tstate);
33979 if (PyErr_Occurred()) SWIG_fail;
33980 }
33981 resultobj = SWIG_From_int(static_cast< int >(result));
33982 return resultobj;
33983 fail:
33984 return NULL;
33985 }
33986
33987
33988 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33989 PyObject *resultobj = 0;
33990 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33991 wxDragResult arg2 ;
33992 bool result;
33993 void *argp1 = 0 ;
33994 int res1 = 0 ;
33995 int val2 ;
33996 int ecode2 = 0 ;
33997 PyObject * obj0 = 0 ;
33998 PyObject * obj1 = 0 ;
33999 char * kwnames[] = {
34000 (char *) "self",(char *) "effect", NULL
34001 };
34002
34003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34005 if (!SWIG_IsOK(res1)) {
34006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34007 }
34008 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34009 ecode2 = SWIG_AsVal_int(obj1, &val2);
34010 if (!SWIG_IsOK(ecode2)) {
34011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34012 }
34013 arg2 = static_cast< wxDragResult >(val2);
34014 {
34015 PyThreadState* __tstate = wxPyBeginAllowThreads();
34016 result = (bool)(arg1)->GiveFeedback(arg2);
34017 wxPyEndAllowThreads(__tstate);
34018 if (PyErr_Occurred()) SWIG_fail;
34019 }
34020 {
34021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34022 }
34023 return resultobj;
34024 fail:
34025 return NULL;
34026 }
34027
34028
34029 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34030 PyObject *obj;
34031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34032 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34033 return SWIG_Py_Void();
34034 }
34035
34036 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34037 return SWIG_Python_InitShadowInstance(args);
34038 }
34039
34040 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34041 PyObject *resultobj = 0;
34042 wxDataObject *arg1 = (wxDataObject *) NULL ;
34043 wxPyDropTarget *result = 0 ;
34044 int res1 = 0 ;
34045 PyObject * obj0 = 0 ;
34046 char * kwnames[] = {
34047 (char *) "dataObject", NULL
34048 };
34049
34050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34051 if (obj0) {
34052 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34053 if (!SWIG_IsOK(res1)) {
34054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34055 }
34056 }
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34064 return resultobj;
34065 fail:
34066 return NULL;
34067 }
34068
34069
34070 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34071 PyObject *resultobj = 0;
34072 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34073 PyObject *arg2 = (PyObject *) 0 ;
34074 PyObject *arg3 = (PyObject *) 0 ;
34075 void *argp1 = 0 ;
34076 int res1 = 0 ;
34077 PyObject * obj0 = 0 ;
34078 PyObject * obj1 = 0 ;
34079 PyObject * obj2 = 0 ;
34080 char * kwnames[] = {
34081 (char *) "self",(char *) "self",(char *) "_class", NULL
34082 };
34083
34084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34088 }
34089 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34090 arg2 = obj1;
34091 arg3 = obj2;
34092 {
34093 PyThreadState* __tstate = wxPyBeginAllowThreads();
34094 (arg1)->_setCallbackInfo(arg2,arg3);
34095 wxPyEndAllowThreads(__tstate);
34096 if (PyErr_Occurred()) SWIG_fail;
34097 }
34098 resultobj = SWIG_Py_Void();
34099 return resultobj;
34100 fail:
34101 return NULL;
34102 }
34103
34104
34105 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34106 PyObject *resultobj = 0;
34107 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34108 void *argp1 = 0 ;
34109 int res1 = 0 ;
34110 PyObject *swig_obj[1] ;
34111
34112 if (!args) SWIG_fail;
34113 swig_obj[0] = args;
34114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34115 if (!SWIG_IsOK(res1)) {
34116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34117 }
34118 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34119 {
34120 PyThreadState* __tstate = wxPyBeginAllowThreads();
34121 delete arg1;
34122
34123 wxPyEndAllowThreads(__tstate);
34124 if (PyErr_Occurred()) SWIG_fail;
34125 }
34126 resultobj = SWIG_Py_Void();
34127 return resultobj;
34128 fail:
34129 return NULL;
34130 }
34131
34132
34133 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34134 PyObject *resultobj = 0;
34135 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34136 wxDataObject *result = 0 ;
34137 void *argp1 = 0 ;
34138 int res1 = 0 ;
34139 PyObject *swig_obj[1] ;
34140
34141 if (!args) SWIG_fail;
34142 swig_obj[0] = args;
34143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34144 if (!SWIG_IsOK(res1)) {
34145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34146 }
34147 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34148 {
34149 PyThreadState* __tstate = wxPyBeginAllowThreads();
34150 result = (wxDataObject *)(arg1)->GetDataObject();
34151 wxPyEndAllowThreads(__tstate);
34152 if (PyErr_Occurred()) SWIG_fail;
34153 }
34154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34155 return resultobj;
34156 fail:
34157 return NULL;
34158 }
34159
34160
34161 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34162 PyObject *resultobj = 0;
34163 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34164 wxDataObject *arg2 = (wxDataObject *) 0 ;
34165 void *argp1 = 0 ;
34166 int res1 = 0 ;
34167 int res2 = 0 ;
34168 PyObject * obj0 = 0 ;
34169 PyObject * obj1 = 0 ;
34170 char * kwnames[] = {
34171 (char *) "self",(char *) "dataObject", NULL
34172 };
34173
34174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34176 if (!SWIG_IsOK(res1)) {
34177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34178 }
34179 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34180 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34181 if (!SWIG_IsOK(res2)) {
34182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34183 }
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 (arg1)->SetDataObject(arg2);
34187 wxPyEndAllowThreads(__tstate);
34188 if (PyErr_Occurred()) SWIG_fail;
34189 }
34190 resultobj = SWIG_Py_Void();
34191 return resultobj;
34192 fail:
34193 return NULL;
34194 }
34195
34196
34197 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34198 PyObject *resultobj = 0;
34199 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34200 int arg2 ;
34201 int arg3 ;
34202 wxDragResult arg4 ;
34203 wxDragResult result;
34204 void *argp1 = 0 ;
34205 int res1 = 0 ;
34206 int val2 ;
34207 int ecode2 = 0 ;
34208 int val3 ;
34209 int ecode3 = 0 ;
34210 int val4 ;
34211 int ecode4 = 0 ;
34212 PyObject * obj0 = 0 ;
34213 PyObject * obj1 = 0 ;
34214 PyObject * obj2 = 0 ;
34215 PyObject * obj3 = 0 ;
34216 char * kwnames[] = {
34217 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34218 };
34219
34220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34222 if (!SWIG_IsOK(res1)) {
34223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34224 }
34225 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34226 ecode2 = SWIG_AsVal_int(obj1, &val2);
34227 if (!SWIG_IsOK(ecode2)) {
34228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34229 }
34230 arg2 = static_cast< int >(val2);
34231 ecode3 = SWIG_AsVal_int(obj2, &val3);
34232 if (!SWIG_IsOK(ecode3)) {
34233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34234 }
34235 arg3 = static_cast< int >(val3);
34236 ecode4 = SWIG_AsVal_int(obj3, &val4);
34237 if (!SWIG_IsOK(ecode4)) {
34238 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34239 }
34240 arg4 = static_cast< wxDragResult >(val4);
34241 {
34242 PyThreadState* __tstate = wxPyBeginAllowThreads();
34243 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34244 wxPyEndAllowThreads(__tstate);
34245 if (PyErr_Occurred()) SWIG_fail;
34246 }
34247 resultobj = SWIG_From_int(static_cast< int >(result));
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34255 PyObject *resultobj = 0;
34256 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34257 int arg2 ;
34258 int arg3 ;
34259 wxDragResult arg4 ;
34260 wxDragResult result;
34261 void *argp1 = 0 ;
34262 int res1 = 0 ;
34263 int val2 ;
34264 int ecode2 = 0 ;
34265 int val3 ;
34266 int ecode3 = 0 ;
34267 int val4 ;
34268 int ecode4 = 0 ;
34269 PyObject * obj0 = 0 ;
34270 PyObject * obj1 = 0 ;
34271 PyObject * obj2 = 0 ;
34272 PyObject * obj3 = 0 ;
34273 char * kwnames[] = {
34274 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34275 };
34276
34277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34279 if (!SWIG_IsOK(res1)) {
34280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34281 }
34282 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34283 ecode2 = SWIG_AsVal_int(obj1, &val2);
34284 if (!SWIG_IsOK(ecode2)) {
34285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34286 }
34287 arg2 = static_cast< int >(val2);
34288 ecode3 = SWIG_AsVal_int(obj2, &val3);
34289 if (!SWIG_IsOK(ecode3)) {
34290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34291 }
34292 arg3 = static_cast< int >(val3);
34293 ecode4 = SWIG_AsVal_int(obj3, &val4);
34294 if (!SWIG_IsOK(ecode4)) {
34295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34296 }
34297 arg4 = static_cast< wxDragResult >(val4);
34298 {
34299 PyThreadState* __tstate = wxPyBeginAllowThreads();
34300 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34301 wxPyEndAllowThreads(__tstate);
34302 if (PyErr_Occurred()) SWIG_fail;
34303 }
34304 resultobj = SWIG_From_int(static_cast< int >(result));
34305 return resultobj;
34306 fail:
34307 return NULL;
34308 }
34309
34310
34311 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34312 PyObject *resultobj = 0;
34313 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34314 void *argp1 = 0 ;
34315 int res1 = 0 ;
34316 PyObject *swig_obj[1] ;
34317
34318 if (!args) SWIG_fail;
34319 swig_obj[0] = args;
34320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34321 if (!SWIG_IsOK(res1)) {
34322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34323 }
34324 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34325 {
34326 PyThreadState* __tstate = wxPyBeginAllowThreads();
34327 (arg1)->OnLeave();
34328 wxPyEndAllowThreads(__tstate);
34329 if (PyErr_Occurred()) SWIG_fail;
34330 }
34331 resultobj = SWIG_Py_Void();
34332 return resultobj;
34333 fail:
34334 return NULL;
34335 }
34336
34337
34338 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34339 PyObject *resultobj = 0;
34340 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34341 int arg2 ;
34342 int arg3 ;
34343 bool result;
34344 void *argp1 = 0 ;
34345 int res1 = 0 ;
34346 int val2 ;
34347 int ecode2 = 0 ;
34348 int val3 ;
34349 int ecode3 = 0 ;
34350 PyObject * obj0 = 0 ;
34351 PyObject * obj1 = 0 ;
34352 PyObject * obj2 = 0 ;
34353 char * kwnames[] = {
34354 (char *) "self",(char *) "x",(char *) "y", NULL
34355 };
34356
34357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34359 if (!SWIG_IsOK(res1)) {
34360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34361 }
34362 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34363 ecode2 = SWIG_AsVal_int(obj1, &val2);
34364 if (!SWIG_IsOK(ecode2)) {
34365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34366 }
34367 arg2 = static_cast< int >(val2);
34368 ecode3 = SWIG_AsVal_int(obj2, &val3);
34369 if (!SWIG_IsOK(ecode3)) {
34370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34371 }
34372 arg3 = static_cast< int >(val3);
34373 {
34374 PyThreadState* __tstate = wxPyBeginAllowThreads();
34375 result = (bool)(arg1)->OnDrop(arg2,arg3);
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 {
34380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34381 }
34382 return resultobj;
34383 fail:
34384 return NULL;
34385 }
34386
34387
34388 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34389 PyObject *resultobj = 0;
34390 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34391 bool result;
34392 void *argp1 = 0 ;
34393 int res1 = 0 ;
34394 PyObject *swig_obj[1] ;
34395
34396 if (!args) SWIG_fail;
34397 swig_obj[0] = args;
34398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34399 if (!SWIG_IsOK(res1)) {
34400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34401 }
34402 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34403 {
34404 PyThreadState* __tstate = wxPyBeginAllowThreads();
34405 result = (bool)(arg1)->GetData();
34406 wxPyEndAllowThreads(__tstate);
34407 if (PyErr_Occurred()) SWIG_fail;
34408 }
34409 {
34410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34411 }
34412 return resultobj;
34413 fail:
34414 return NULL;
34415 }
34416
34417
34418 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34419 PyObject *resultobj = 0;
34420 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34421 wxDragResult arg2 ;
34422 void *argp1 = 0 ;
34423 int res1 = 0 ;
34424 int val2 ;
34425 int ecode2 = 0 ;
34426 PyObject * obj0 = 0 ;
34427 PyObject * obj1 = 0 ;
34428 char * kwnames[] = {
34429 (char *) "self",(char *) "action", NULL
34430 };
34431
34432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34434 if (!SWIG_IsOK(res1)) {
34435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34436 }
34437 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34438 ecode2 = SWIG_AsVal_int(obj1, &val2);
34439 if (!SWIG_IsOK(ecode2)) {
34440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34441 }
34442 arg2 = static_cast< wxDragResult >(val2);
34443 {
34444 PyThreadState* __tstate = wxPyBeginAllowThreads();
34445 (arg1)->SetDefaultAction(arg2);
34446 wxPyEndAllowThreads(__tstate);
34447 if (PyErr_Occurred()) SWIG_fail;
34448 }
34449 resultobj = SWIG_Py_Void();
34450 return resultobj;
34451 fail:
34452 return NULL;
34453 }
34454
34455
34456 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34457 PyObject *resultobj = 0;
34458 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34459 wxDragResult result;
34460 void *argp1 = 0 ;
34461 int res1 = 0 ;
34462 PyObject *swig_obj[1] ;
34463
34464 if (!args) SWIG_fail;
34465 swig_obj[0] = args;
34466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34467 if (!SWIG_IsOK(res1)) {
34468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34469 }
34470 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34471 {
34472 PyThreadState* __tstate = wxPyBeginAllowThreads();
34473 result = (wxDragResult)(arg1)->GetDefaultAction();
34474 wxPyEndAllowThreads(__tstate);
34475 if (PyErr_Occurred()) SWIG_fail;
34476 }
34477 resultobj = SWIG_From_int(static_cast< int >(result));
34478 return resultobj;
34479 fail:
34480 return NULL;
34481 }
34482
34483
34484 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34485 PyObject *obj;
34486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34487 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34488 return SWIG_Py_Void();
34489 }
34490
34491 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34492 return SWIG_Python_InitShadowInstance(args);
34493 }
34494
34495 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34496 PyObject *resultobj = 0;
34497 wxPyTextDropTarget *result = 0 ;
34498
34499 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34500 {
34501 PyThreadState* __tstate = wxPyBeginAllowThreads();
34502 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34503 wxPyEndAllowThreads(__tstate);
34504 if (PyErr_Occurred()) SWIG_fail;
34505 }
34506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34507 return resultobj;
34508 fail:
34509 return NULL;
34510 }
34511
34512
34513 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34514 PyObject *resultobj = 0;
34515 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34516 PyObject *arg2 = (PyObject *) 0 ;
34517 PyObject *arg3 = (PyObject *) 0 ;
34518 void *argp1 = 0 ;
34519 int res1 = 0 ;
34520 PyObject * obj0 = 0 ;
34521 PyObject * obj1 = 0 ;
34522 PyObject * obj2 = 0 ;
34523 char * kwnames[] = {
34524 (char *) "self",(char *) "self",(char *) "_class", NULL
34525 };
34526
34527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34529 if (!SWIG_IsOK(res1)) {
34530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34531 }
34532 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34533 arg2 = obj1;
34534 arg3 = obj2;
34535 {
34536 PyThreadState* __tstate = wxPyBeginAllowThreads();
34537 (arg1)->_setCallbackInfo(arg2,arg3);
34538 wxPyEndAllowThreads(__tstate);
34539 if (PyErr_Occurred()) SWIG_fail;
34540 }
34541 resultobj = SWIG_Py_Void();
34542 return resultobj;
34543 fail:
34544 return NULL;
34545 }
34546
34547
34548 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34549 PyObject *resultobj = 0;
34550 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34551 int arg2 ;
34552 int arg3 ;
34553 wxString *arg4 = 0 ;
34554 bool result;
34555 void *argp1 = 0 ;
34556 int res1 = 0 ;
34557 int val2 ;
34558 int ecode2 = 0 ;
34559 int val3 ;
34560 int ecode3 = 0 ;
34561 bool temp4 = false ;
34562 PyObject * obj0 = 0 ;
34563 PyObject * obj1 = 0 ;
34564 PyObject * obj2 = 0 ;
34565 PyObject * obj3 = 0 ;
34566 char * kwnames[] = {
34567 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34568 };
34569
34570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34572 if (!SWIG_IsOK(res1)) {
34573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34574 }
34575 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34576 ecode2 = SWIG_AsVal_int(obj1, &val2);
34577 if (!SWIG_IsOK(ecode2)) {
34578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34579 }
34580 arg2 = static_cast< int >(val2);
34581 ecode3 = SWIG_AsVal_int(obj2, &val3);
34582 if (!SWIG_IsOK(ecode3)) {
34583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34584 }
34585 arg3 = static_cast< int >(val3);
34586 {
34587 arg4 = wxString_in_helper(obj3);
34588 if (arg4 == NULL) SWIG_fail;
34589 temp4 = true;
34590 }
34591 {
34592 PyThreadState* __tstate = wxPyBeginAllowThreads();
34593 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34594 wxPyEndAllowThreads(__tstate);
34595 if (PyErr_Occurred()) SWIG_fail;
34596 }
34597 {
34598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34599 }
34600 {
34601 if (temp4)
34602 delete arg4;
34603 }
34604 return resultobj;
34605 fail:
34606 {
34607 if (temp4)
34608 delete arg4;
34609 }
34610 return NULL;
34611 }
34612
34613
34614 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34615 PyObject *resultobj = 0;
34616 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34617 int arg2 ;
34618 int arg3 ;
34619 wxDragResult arg4 ;
34620 wxDragResult result;
34621 void *argp1 = 0 ;
34622 int res1 = 0 ;
34623 int val2 ;
34624 int ecode2 = 0 ;
34625 int val3 ;
34626 int ecode3 = 0 ;
34627 int val4 ;
34628 int ecode4 = 0 ;
34629 PyObject * obj0 = 0 ;
34630 PyObject * obj1 = 0 ;
34631 PyObject * obj2 = 0 ;
34632 PyObject * obj3 = 0 ;
34633 char * kwnames[] = {
34634 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34635 };
34636
34637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34639 if (!SWIG_IsOK(res1)) {
34640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34641 }
34642 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34643 ecode2 = SWIG_AsVal_int(obj1, &val2);
34644 if (!SWIG_IsOK(ecode2)) {
34645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34646 }
34647 arg2 = static_cast< int >(val2);
34648 ecode3 = SWIG_AsVal_int(obj2, &val3);
34649 if (!SWIG_IsOK(ecode3)) {
34650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34651 }
34652 arg3 = static_cast< int >(val3);
34653 ecode4 = SWIG_AsVal_int(obj3, &val4);
34654 if (!SWIG_IsOK(ecode4)) {
34655 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34656 }
34657 arg4 = static_cast< wxDragResult >(val4);
34658 {
34659 PyThreadState* __tstate = wxPyBeginAllowThreads();
34660 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34661 wxPyEndAllowThreads(__tstate);
34662 if (PyErr_Occurred()) SWIG_fail;
34663 }
34664 resultobj = SWIG_From_int(static_cast< int >(result));
34665 return resultobj;
34666 fail:
34667 return NULL;
34668 }
34669
34670
34671 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34672 PyObject *resultobj = 0;
34673 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34674 int arg2 ;
34675 int arg3 ;
34676 wxDragResult arg4 ;
34677 wxDragResult result;
34678 void *argp1 = 0 ;
34679 int res1 = 0 ;
34680 int val2 ;
34681 int ecode2 = 0 ;
34682 int val3 ;
34683 int ecode3 = 0 ;
34684 int val4 ;
34685 int ecode4 = 0 ;
34686 PyObject * obj0 = 0 ;
34687 PyObject * obj1 = 0 ;
34688 PyObject * obj2 = 0 ;
34689 PyObject * obj3 = 0 ;
34690 char * kwnames[] = {
34691 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34692 };
34693
34694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34696 if (!SWIG_IsOK(res1)) {
34697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34698 }
34699 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34700 ecode2 = SWIG_AsVal_int(obj1, &val2);
34701 if (!SWIG_IsOK(ecode2)) {
34702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34703 }
34704 arg2 = static_cast< int >(val2);
34705 ecode3 = SWIG_AsVal_int(obj2, &val3);
34706 if (!SWIG_IsOK(ecode3)) {
34707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34708 }
34709 arg3 = static_cast< int >(val3);
34710 ecode4 = SWIG_AsVal_int(obj3, &val4);
34711 if (!SWIG_IsOK(ecode4)) {
34712 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34713 }
34714 arg4 = static_cast< wxDragResult >(val4);
34715 {
34716 PyThreadState* __tstate = wxPyBeginAllowThreads();
34717 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34718 wxPyEndAllowThreads(__tstate);
34719 if (PyErr_Occurred()) SWIG_fail;
34720 }
34721 resultobj = SWIG_From_int(static_cast< int >(result));
34722 return resultobj;
34723 fail:
34724 return NULL;
34725 }
34726
34727
34728 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34729 PyObject *resultobj = 0;
34730 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34731 void *argp1 = 0 ;
34732 int res1 = 0 ;
34733 PyObject *swig_obj[1] ;
34734
34735 if (!args) SWIG_fail;
34736 swig_obj[0] = args;
34737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34738 if (!SWIG_IsOK(res1)) {
34739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34740 }
34741 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34742 {
34743 PyThreadState* __tstate = wxPyBeginAllowThreads();
34744 (arg1)->OnLeave();
34745 wxPyEndAllowThreads(__tstate);
34746 if (PyErr_Occurred()) SWIG_fail;
34747 }
34748 resultobj = SWIG_Py_Void();
34749 return resultobj;
34750 fail:
34751 return NULL;
34752 }
34753
34754
34755 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34756 PyObject *resultobj = 0;
34757 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34758 int arg2 ;
34759 int arg3 ;
34760 bool result;
34761 void *argp1 = 0 ;
34762 int res1 = 0 ;
34763 int val2 ;
34764 int ecode2 = 0 ;
34765 int val3 ;
34766 int ecode3 = 0 ;
34767 PyObject * obj0 = 0 ;
34768 PyObject * obj1 = 0 ;
34769 PyObject * obj2 = 0 ;
34770 char * kwnames[] = {
34771 (char *) "self",(char *) "x",(char *) "y", NULL
34772 };
34773
34774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34776 if (!SWIG_IsOK(res1)) {
34777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34778 }
34779 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34780 ecode2 = SWIG_AsVal_int(obj1, &val2);
34781 if (!SWIG_IsOK(ecode2)) {
34782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34783 }
34784 arg2 = static_cast< int >(val2);
34785 ecode3 = SWIG_AsVal_int(obj2, &val3);
34786 if (!SWIG_IsOK(ecode3)) {
34787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34788 }
34789 arg3 = static_cast< int >(val3);
34790 {
34791 PyThreadState* __tstate = wxPyBeginAllowThreads();
34792 result = (bool)(arg1)->OnDrop(arg2,arg3);
34793 wxPyEndAllowThreads(__tstate);
34794 if (PyErr_Occurred()) SWIG_fail;
34795 }
34796 {
34797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34798 }
34799 return resultobj;
34800 fail:
34801 return NULL;
34802 }
34803
34804
34805 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34806 PyObject *resultobj = 0;
34807 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34808 int arg2 ;
34809 int arg3 ;
34810 wxDragResult arg4 ;
34811 wxDragResult result;
34812 void *argp1 = 0 ;
34813 int res1 = 0 ;
34814 int val2 ;
34815 int ecode2 = 0 ;
34816 int val3 ;
34817 int ecode3 = 0 ;
34818 int val4 ;
34819 int ecode4 = 0 ;
34820 PyObject * obj0 = 0 ;
34821 PyObject * obj1 = 0 ;
34822 PyObject * obj2 = 0 ;
34823 PyObject * obj3 = 0 ;
34824 char * kwnames[] = {
34825 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34826 };
34827
34828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34830 if (!SWIG_IsOK(res1)) {
34831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34832 }
34833 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34834 ecode2 = SWIG_AsVal_int(obj1, &val2);
34835 if (!SWIG_IsOK(ecode2)) {
34836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34837 }
34838 arg2 = static_cast< int >(val2);
34839 ecode3 = SWIG_AsVal_int(obj2, &val3);
34840 if (!SWIG_IsOK(ecode3)) {
34841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34842 }
34843 arg3 = static_cast< int >(val3);
34844 ecode4 = SWIG_AsVal_int(obj3, &val4);
34845 if (!SWIG_IsOK(ecode4)) {
34846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34847 }
34848 arg4 = static_cast< wxDragResult >(val4);
34849 {
34850 PyThreadState* __tstate = wxPyBeginAllowThreads();
34851 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34852 wxPyEndAllowThreads(__tstate);
34853 if (PyErr_Occurred()) SWIG_fail;
34854 }
34855 resultobj = SWIG_From_int(static_cast< int >(result));
34856 return resultobj;
34857 fail:
34858 return NULL;
34859 }
34860
34861
34862 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34863 PyObject *obj;
34864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34865 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34866 return SWIG_Py_Void();
34867 }
34868
34869 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34870 return SWIG_Python_InitShadowInstance(args);
34871 }
34872
34873 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34874 PyObject *resultobj = 0;
34875 wxPyFileDropTarget *result = 0 ;
34876
34877 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34878 {
34879 PyThreadState* __tstate = wxPyBeginAllowThreads();
34880 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34881 wxPyEndAllowThreads(__tstate);
34882 if (PyErr_Occurred()) SWIG_fail;
34883 }
34884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34892 PyObject *resultobj = 0;
34893 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34894 PyObject *arg2 = (PyObject *) 0 ;
34895 PyObject *arg3 = (PyObject *) 0 ;
34896 void *argp1 = 0 ;
34897 int res1 = 0 ;
34898 PyObject * obj0 = 0 ;
34899 PyObject * obj1 = 0 ;
34900 PyObject * obj2 = 0 ;
34901 char * kwnames[] = {
34902 (char *) "self",(char *) "self",(char *) "_class", NULL
34903 };
34904
34905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34907 if (!SWIG_IsOK(res1)) {
34908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34909 }
34910 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34911 arg2 = obj1;
34912 arg3 = obj2;
34913 {
34914 PyThreadState* __tstate = wxPyBeginAllowThreads();
34915 (arg1)->_setCallbackInfo(arg2,arg3);
34916 wxPyEndAllowThreads(__tstate);
34917 if (PyErr_Occurred()) SWIG_fail;
34918 }
34919 resultobj = SWIG_Py_Void();
34920 return resultobj;
34921 fail:
34922 return NULL;
34923 }
34924
34925
34926 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34927 PyObject *resultobj = 0;
34928 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34929 int arg2 ;
34930 int arg3 ;
34931 wxArrayString *arg4 = 0 ;
34932 bool result;
34933 void *argp1 = 0 ;
34934 int res1 = 0 ;
34935 int val2 ;
34936 int ecode2 = 0 ;
34937 int val3 ;
34938 int ecode3 = 0 ;
34939 bool temp4 = false ;
34940 PyObject * obj0 = 0 ;
34941 PyObject * obj1 = 0 ;
34942 PyObject * obj2 = 0 ;
34943 PyObject * obj3 = 0 ;
34944 char * kwnames[] = {
34945 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34946 };
34947
34948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34950 if (!SWIG_IsOK(res1)) {
34951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34952 }
34953 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34954 ecode2 = SWIG_AsVal_int(obj1, &val2);
34955 if (!SWIG_IsOK(ecode2)) {
34956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34957 }
34958 arg2 = static_cast< int >(val2);
34959 ecode3 = SWIG_AsVal_int(obj2, &val3);
34960 if (!SWIG_IsOK(ecode3)) {
34961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34962 }
34963 arg3 = static_cast< int >(val3);
34964 {
34965 if (! PySequence_Check(obj3)) {
34966 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34967 SWIG_fail;
34968 }
34969 arg4 = new wxArrayString;
34970 temp4 = true;
34971 int i, len=PySequence_Length(obj3);
34972 for (i=0; i<len; i++) {
34973 PyObject* item = PySequence_GetItem(obj3, i);
34974 wxString* s = wxString_in_helper(item);
34975 if (PyErr_Occurred()) SWIG_fail;
34976 arg4->Add(*s);
34977 delete s;
34978 Py_DECREF(item);
34979 }
34980 }
34981 {
34982 PyThreadState* __tstate = wxPyBeginAllowThreads();
34983 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
34984 wxPyEndAllowThreads(__tstate);
34985 if (PyErr_Occurred()) SWIG_fail;
34986 }
34987 {
34988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34989 }
34990 {
34991 if (temp4) delete arg4;
34992 }
34993 return resultobj;
34994 fail:
34995 {
34996 if (temp4) delete arg4;
34997 }
34998 return NULL;
34999 }
35000
35001
35002 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35003 PyObject *resultobj = 0;
35004 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35005 int arg2 ;
35006 int arg3 ;
35007 wxDragResult arg4 ;
35008 wxDragResult result;
35009 void *argp1 = 0 ;
35010 int res1 = 0 ;
35011 int val2 ;
35012 int ecode2 = 0 ;
35013 int val3 ;
35014 int ecode3 = 0 ;
35015 int val4 ;
35016 int ecode4 = 0 ;
35017 PyObject * obj0 = 0 ;
35018 PyObject * obj1 = 0 ;
35019 PyObject * obj2 = 0 ;
35020 PyObject * obj3 = 0 ;
35021 char * kwnames[] = {
35022 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35023 };
35024
35025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35027 if (!SWIG_IsOK(res1)) {
35028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35029 }
35030 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35031 ecode2 = SWIG_AsVal_int(obj1, &val2);
35032 if (!SWIG_IsOK(ecode2)) {
35033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35034 }
35035 arg2 = static_cast< int >(val2);
35036 ecode3 = SWIG_AsVal_int(obj2, &val3);
35037 if (!SWIG_IsOK(ecode3)) {
35038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35039 }
35040 arg3 = static_cast< int >(val3);
35041 ecode4 = SWIG_AsVal_int(obj3, &val4);
35042 if (!SWIG_IsOK(ecode4)) {
35043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35044 }
35045 arg4 = static_cast< wxDragResult >(val4);
35046 {
35047 PyThreadState* __tstate = wxPyBeginAllowThreads();
35048 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35049 wxPyEndAllowThreads(__tstate);
35050 if (PyErr_Occurred()) SWIG_fail;
35051 }
35052 resultobj = SWIG_From_int(static_cast< int >(result));
35053 return resultobj;
35054 fail:
35055 return NULL;
35056 }
35057
35058
35059 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35060 PyObject *resultobj = 0;
35061 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35062 int arg2 ;
35063 int arg3 ;
35064 wxDragResult arg4 ;
35065 wxDragResult result;
35066 void *argp1 = 0 ;
35067 int res1 = 0 ;
35068 int val2 ;
35069 int ecode2 = 0 ;
35070 int val3 ;
35071 int ecode3 = 0 ;
35072 int val4 ;
35073 int ecode4 = 0 ;
35074 PyObject * obj0 = 0 ;
35075 PyObject * obj1 = 0 ;
35076 PyObject * obj2 = 0 ;
35077 PyObject * obj3 = 0 ;
35078 char * kwnames[] = {
35079 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35080 };
35081
35082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35084 if (!SWIG_IsOK(res1)) {
35085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35086 }
35087 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35088 ecode2 = SWIG_AsVal_int(obj1, &val2);
35089 if (!SWIG_IsOK(ecode2)) {
35090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35091 }
35092 arg2 = static_cast< int >(val2);
35093 ecode3 = SWIG_AsVal_int(obj2, &val3);
35094 if (!SWIG_IsOK(ecode3)) {
35095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35096 }
35097 arg3 = static_cast< int >(val3);
35098 ecode4 = SWIG_AsVal_int(obj3, &val4);
35099 if (!SWIG_IsOK(ecode4)) {
35100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35101 }
35102 arg4 = static_cast< wxDragResult >(val4);
35103 {
35104 PyThreadState* __tstate = wxPyBeginAllowThreads();
35105 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35106 wxPyEndAllowThreads(__tstate);
35107 if (PyErr_Occurred()) SWIG_fail;
35108 }
35109 resultobj = SWIG_From_int(static_cast< int >(result));
35110 return resultobj;
35111 fail:
35112 return NULL;
35113 }
35114
35115
35116 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35117 PyObject *resultobj = 0;
35118 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35119 void *argp1 = 0 ;
35120 int res1 = 0 ;
35121 PyObject *swig_obj[1] ;
35122
35123 if (!args) SWIG_fail;
35124 swig_obj[0] = args;
35125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35126 if (!SWIG_IsOK(res1)) {
35127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35128 }
35129 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35130 {
35131 PyThreadState* __tstate = wxPyBeginAllowThreads();
35132 (arg1)->OnLeave();
35133 wxPyEndAllowThreads(__tstate);
35134 if (PyErr_Occurred()) SWIG_fail;
35135 }
35136 resultobj = SWIG_Py_Void();
35137 return resultobj;
35138 fail:
35139 return NULL;
35140 }
35141
35142
35143 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35144 PyObject *resultobj = 0;
35145 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35146 int arg2 ;
35147 int arg3 ;
35148 bool result;
35149 void *argp1 = 0 ;
35150 int res1 = 0 ;
35151 int val2 ;
35152 int ecode2 = 0 ;
35153 int val3 ;
35154 int ecode3 = 0 ;
35155 PyObject * obj0 = 0 ;
35156 PyObject * obj1 = 0 ;
35157 PyObject * obj2 = 0 ;
35158 char * kwnames[] = {
35159 (char *) "self",(char *) "x",(char *) "y", NULL
35160 };
35161
35162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35164 if (!SWIG_IsOK(res1)) {
35165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35166 }
35167 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35168 ecode2 = SWIG_AsVal_int(obj1, &val2);
35169 if (!SWIG_IsOK(ecode2)) {
35170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35171 }
35172 arg2 = static_cast< int >(val2);
35173 ecode3 = SWIG_AsVal_int(obj2, &val3);
35174 if (!SWIG_IsOK(ecode3)) {
35175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35176 }
35177 arg3 = static_cast< int >(val3);
35178 {
35179 PyThreadState* __tstate = wxPyBeginAllowThreads();
35180 result = (bool)(arg1)->OnDrop(arg2,arg3);
35181 wxPyEndAllowThreads(__tstate);
35182 if (PyErr_Occurred()) SWIG_fail;
35183 }
35184 {
35185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35186 }
35187 return resultobj;
35188 fail:
35189 return NULL;
35190 }
35191
35192
35193 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35194 PyObject *resultobj = 0;
35195 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35196 int arg2 ;
35197 int arg3 ;
35198 wxDragResult arg4 ;
35199 wxDragResult result;
35200 void *argp1 = 0 ;
35201 int res1 = 0 ;
35202 int val2 ;
35203 int ecode2 = 0 ;
35204 int val3 ;
35205 int ecode3 = 0 ;
35206 int val4 ;
35207 int ecode4 = 0 ;
35208 PyObject * obj0 = 0 ;
35209 PyObject * obj1 = 0 ;
35210 PyObject * obj2 = 0 ;
35211 PyObject * obj3 = 0 ;
35212 char * kwnames[] = {
35213 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35214 };
35215
35216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35218 if (!SWIG_IsOK(res1)) {
35219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35220 }
35221 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35222 ecode2 = SWIG_AsVal_int(obj1, &val2);
35223 if (!SWIG_IsOK(ecode2)) {
35224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35225 }
35226 arg2 = static_cast< int >(val2);
35227 ecode3 = SWIG_AsVal_int(obj2, &val3);
35228 if (!SWIG_IsOK(ecode3)) {
35229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35230 }
35231 arg3 = static_cast< int >(val3);
35232 ecode4 = SWIG_AsVal_int(obj3, &val4);
35233 if (!SWIG_IsOK(ecode4)) {
35234 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35235 }
35236 arg4 = static_cast< wxDragResult >(val4);
35237 {
35238 PyThreadState* __tstate = wxPyBeginAllowThreads();
35239 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 resultobj = SWIG_From_int(static_cast< int >(result));
35244 return resultobj;
35245 fail:
35246 return NULL;
35247 }
35248
35249
35250 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35251 PyObject *obj;
35252 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35253 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35254 return SWIG_Py_Void();
35255 }
35256
35257 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35258 return SWIG_Python_InitShadowInstance(args);
35259 }
35260
35261 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35262 PyObject *resultobj = 0;
35263 wxClipboard *result = 0 ;
35264
35265 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35266 {
35267 PyThreadState* __tstate = wxPyBeginAllowThreads();
35268 result = (wxClipboard *)new wxClipboard();
35269 wxPyEndAllowThreads(__tstate);
35270 if (PyErr_Occurred()) SWIG_fail;
35271 }
35272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35273 return resultobj;
35274 fail:
35275 return NULL;
35276 }
35277
35278
35279 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35280 PyObject *resultobj = 0;
35281 wxClipboard *arg1 = (wxClipboard *) 0 ;
35282 void *argp1 = 0 ;
35283 int res1 = 0 ;
35284 PyObject *swig_obj[1] ;
35285
35286 if (!args) SWIG_fail;
35287 swig_obj[0] = args;
35288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35289 if (!SWIG_IsOK(res1)) {
35290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35291 }
35292 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35293 {
35294 PyThreadState* __tstate = wxPyBeginAllowThreads();
35295 delete arg1;
35296
35297 wxPyEndAllowThreads(__tstate);
35298 if (PyErr_Occurred()) SWIG_fail;
35299 }
35300 resultobj = SWIG_Py_Void();
35301 return resultobj;
35302 fail:
35303 return NULL;
35304 }
35305
35306
35307 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35308 PyObject *resultobj = 0;
35309 wxClipboard *arg1 = (wxClipboard *) 0 ;
35310 bool result;
35311 void *argp1 = 0 ;
35312 int res1 = 0 ;
35313 PyObject *swig_obj[1] ;
35314
35315 if (!args) SWIG_fail;
35316 swig_obj[0] = args;
35317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35318 if (!SWIG_IsOK(res1)) {
35319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35320 }
35321 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35322 {
35323 PyThreadState* __tstate = wxPyBeginAllowThreads();
35324 result = (bool)(arg1)->Open();
35325 wxPyEndAllowThreads(__tstate);
35326 if (PyErr_Occurred()) SWIG_fail;
35327 }
35328 {
35329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35330 }
35331 return resultobj;
35332 fail:
35333 return NULL;
35334 }
35335
35336
35337 SWIGINTERN PyObject *_wrap_Clipboard_Close(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, 0 | 0 );
35347 if (!SWIG_IsOK(res1)) {
35348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35349 }
35350 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35351 {
35352 PyThreadState* __tstate = wxPyBeginAllowThreads();
35353 (arg1)->Close();
35354 wxPyEndAllowThreads(__tstate);
35355 if (PyErr_Occurred()) SWIG_fail;
35356 }
35357 resultobj = SWIG_Py_Void();
35358 return resultobj;
35359 fail:
35360 return NULL;
35361 }
35362
35363
35364 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35365 PyObject *resultobj = 0;
35366 wxClipboard *arg1 = (wxClipboard *) 0 ;
35367 bool result;
35368 void *argp1 = 0 ;
35369 int res1 = 0 ;
35370 PyObject *swig_obj[1] ;
35371
35372 if (!args) SWIG_fail;
35373 swig_obj[0] = args;
35374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35375 if (!SWIG_IsOK(res1)) {
35376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35377 }
35378 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35379 {
35380 PyThreadState* __tstate = wxPyBeginAllowThreads();
35381 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35382 wxPyEndAllowThreads(__tstate);
35383 if (PyErr_Occurred()) SWIG_fail;
35384 }
35385 {
35386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35387 }
35388 return resultobj;
35389 fail:
35390 return NULL;
35391 }
35392
35393
35394 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35395 PyObject *resultobj = 0;
35396 wxClipboard *arg1 = (wxClipboard *) 0 ;
35397 wxDataObject *arg2 = (wxDataObject *) 0 ;
35398 bool result;
35399 void *argp1 = 0 ;
35400 int res1 = 0 ;
35401 int res2 = 0 ;
35402 PyObject * obj0 = 0 ;
35403 PyObject * obj1 = 0 ;
35404 char * kwnames[] = {
35405 (char *) "self",(char *) "data", NULL
35406 };
35407
35408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35410 if (!SWIG_IsOK(res1)) {
35411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35412 }
35413 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35414 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35415 if (!SWIG_IsOK(res2)) {
35416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35417 }
35418 {
35419 PyThreadState* __tstate = wxPyBeginAllowThreads();
35420 result = (bool)(arg1)->AddData(arg2);
35421 wxPyEndAllowThreads(__tstate);
35422 if (PyErr_Occurred()) SWIG_fail;
35423 }
35424 {
35425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35426 }
35427 return resultobj;
35428 fail:
35429 return NULL;
35430 }
35431
35432
35433 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35434 PyObject *resultobj = 0;
35435 wxClipboard *arg1 = (wxClipboard *) 0 ;
35436 wxDataObject *arg2 = (wxDataObject *) 0 ;
35437 bool result;
35438 void *argp1 = 0 ;
35439 int res1 = 0 ;
35440 int res2 = 0 ;
35441 PyObject * obj0 = 0 ;
35442 PyObject * obj1 = 0 ;
35443 char * kwnames[] = {
35444 (char *) "self",(char *) "data", NULL
35445 };
35446
35447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35449 if (!SWIG_IsOK(res1)) {
35450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35451 }
35452 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35453 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35454 if (!SWIG_IsOK(res2)) {
35455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35456 }
35457 {
35458 PyThreadState* __tstate = wxPyBeginAllowThreads();
35459 result = (bool)(arg1)->SetData(arg2);
35460 wxPyEndAllowThreads(__tstate);
35461 if (PyErr_Occurred()) SWIG_fail;
35462 }
35463 {
35464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35465 }
35466 return resultobj;
35467 fail:
35468 return NULL;
35469 }
35470
35471
35472 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35473 PyObject *resultobj = 0;
35474 wxClipboard *arg1 = (wxClipboard *) 0 ;
35475 wxDataFormat *arg2 = 0 ;
35476 bool result;
35477 void *argp1 = 0 ;
35478 int res1 = 0 ;
35479 void *argp2 = 0 ;
35480 int res2 = 0 ;
35481 PyObject * obj0 = 0 ;
35482 PyObject * obj1 = 0 ;
35483 char * kwnames[] = {
35484 (char *) "self",(char *) "format", NULL
35485 };
35486
35487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35489 if (!SWIG_IsOK(res1)) {
35490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35491 }
35492 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35493 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35494 if (!SWIG_IsOK(res2)) {
35495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35496 }
35497 if (!argp2) {
35498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35499 }
35500 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35501 {
35502 PyThreadState* __tstate = wxPyBeginAllowThreads();
35503 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35504 wxPyEndAllowThreads(__tstate);
35505 if (PyErr_Occurred()) SWIG_fail;
35506 }
35507 {
35508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35509 }
35510 return resultobj;
35511 fail:
35512 return NULL;
35513 }
35514
35515
35516 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35517 PyObject *resultobj = 0;
35518 wxClipboard *arg1 = (wxClipboard *) 0 ;
35519 wxDataObject *arg2 = 0 ;
35520 bool result;
35521 void *argp1 = 0 ;
35522 int res1 = 0 ;
35523 void *argp2 = 0 ;
35524 int res2 = 0 ;
35525 PyObject * obj0 = 0 ;
35526 PyObject * obj1 = 0 ;
35527 char * kwnames[] = {
35528 (char *) "self",(char *) "data", NULL
35529 };
35530
35531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35533 if (!SWIG_IsOK(res1)) {
35534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35535 }
35536 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35537 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35538 if (!SWIG_IsOK(res2)) {
35539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35540 }
35541 if (!argp2) {
35542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35543 }
35544 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35545 {
35546 PyThreadState* __tstate = wxPyBeginAllowThreads();
35547 result = (bool)(arg1)->GetData(*arg2);
35548 wxPyEndAllowThreads(__tstate);
35549 if (PyErr_Occurred()) SWIG_fail;
35550 }
35551 {
35552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35553 }
35554 return resultobj;
35555 fail:
35556 return NULL;
35557 }
35558
35559
35560 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35561 PyObject *resultobj = 0;
35562 wxClipboard *arg1 = (wxClipboard *) 0 ;
35563 void *argp1 = 0 ;
35564 int res1 = 0 ;
35565 PyObject *swig_obj[1] ;
35566
35567 if (!args) SWIG_fail;
35568 swig_obj[0] = args;
35569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35570 if (!SWIG_IsOK(res1)) {
35571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35572 }
35573 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 (arg1)->Clear();
35577 wxPyEndAllowThreads(__tstate);
35578 if (PyErr_Occurred()) SWIG_fail;
35579 }
35580 resultobj = SWIG_Py_Void();
35581 return resultobj;
35582 fail:
35583 return NULL;
35584 }
35585
35586
35587 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35588 PyObject *resultobj = 0;
35589 wxClipboard *arg1 = (wxClipboard *) 0 ;
35590 bool result;
35591 void *argp1 = 0 ;
35592 int res1 = 0 ;
35593 PyObject *swig_obj[1] ;
35594
35595 if (!args) SWIG_fail;
35596 swig_obj[0] = args;
35597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35598 if (!SWIG_IsOK(res1)) {
35599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35600 }
35601 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35602 {
35603 PyThreadState* __tstate = wxPyBeginAllowThreads();
35604 result = (bool)(arg1)->Flush();
35605 wxPyEndAllowThreads(__tstate);
35606 if (PyErr_Occurred()) SWIG_fail;
35607 }
35608 {
35609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35610 }
35611 return resultobj;
35612 fail:
35613 return NULL;
35614 }
35615
35616
35617 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35618 PyObject *resultobj = 0;
35619 wxClipboard *arg1 = (wxClipboard *) 0 ;
35620 bool arg2 = (bool) true ;
35621 void *argp1 = 0 ;
35622 int res1 = 0 ;
35623 bool val2 ;
35624 int ecode2 = 0 ;
35625 PyObject * obj0 = 0 ;
35626 PyObject * obj1 = 0 ;
35627 char * kwnames[] = {
35628 (char *) "self",(char *) "primary", NULL
35629 };
35630
35631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35633 if (!SWIG_IsOK(res1)) {
35634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35635 }
35636 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35637 if (obj1) {
35638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35639 if (!SWIG_IsOK(ecode2)) {
35640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35641 }
35642 arg2 = static_cast< bool >(val2);
35643 }
35644 {
35645 PyThreadState* __tstate = wxPyBeginAllowThreads();
35646 (arg1)->UsePrimarySelection(arg2);
35647 wxPyEndAllowThreads(__tstate);
35648 if (PyErr_Occurred()) SWIG_fail;
35649 }
35650 resultobj = SWIG_Py_Void();
35651 return resultobj;
35652 fail:
35653 return NULL;
35654 }
35655
35656
35657 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35658 PyObject *resultobj = 0;
35659 wxClipboard *result = 0 ;
35660
35661 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35662 {
35663 PyThreadState* __tstate = wxPyBeginAllowThreads();
35664 result = (wxClipboard *)wxClipboard::Get();
35665 wxPyEndAllowThreads(__tstate);
35666 if (PyErr_Occurred()) SWIG_fail;
35667 }
35668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35669 return resultobj;
35670 fail:
35671 return NULL;
35672 }
35673
35674
35675 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35676 PyObject *obj;
35677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35678 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35679 return SWIG_Py_Void();
35680 }
35681
35682 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35683 return SWIG_Python_InitShadowInstance(args);
35684 }
35685
35686 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35687 PyObject *resultobj = 0;
35688 wxClipboard *arg1 = (wxClipboard *) NULL ;
35689 wxClipboardLocker *result = 0 ;
35690 void *argp1 = 0 ;
35691 int res1 = 0 ;
35692 PyObject * obj0 = 0 ;
35693 char * kwnames[] = {
35694 (char *) "clipboard", NULL
35695 };
35696
35697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35698 if (obj0) {
35699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35700 if (!SWIG_IsOK(res1)) {
35701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35702 }
35703 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35704 }
35705 {
35706 PyThreadState* __tstate = wxPyBeginAllowThreads();
35707 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35708 wxPyEndAllowThreads(__tstate);
35709 if (PyErr_Occurred()) SWIG_fail;
35710 }
35711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35712 return resultobj;
35713 fail:
35714 return NULL;
35715 }
35716
35717
35718 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35719 PyObject *resultobj = 0;
35720 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35721 void *argp1 = 0 ;
35722 int res1 = 0 ;
35723 PyObject *swig_obj[1] ;
35724
35725 if (!args) SWIG_fail;
35726 swig_obj[0] = args;
35727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35728 if (!SWIG_IsOK(res1)) {
35729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35730 }
35731 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35732 {
35733 PyThreadState* __tstate = wxPyBeginAllowThreads();
35734 delete arg1;
35735
35736 wxPyEndAllowThreads(__tstate);
35737 if (PyErr_Occurred()) SWIG_fail;
35738 }
35739 resultobj = SWIG_Py_Void();
35740 return resultobj;
35741 fail:
35742 return NULL;
35743 }
35744
35745
35746 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35747 PyObject *resultobj = 0;
35748 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35749 bool result;
35750 void *argp1 = 0 ;
35751 int res1 = 0 ;
35752 PyObject *swig_obj[1] ;
35753
35754 if (!args) SWIG_fail;
35755 swig_obj[0] = args;
35756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35757 if (!SWIG_IsOK(res1)) {
35758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35759 }
35760 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35761 {
35762 PyThreadState* __tstate = wxPyBeginAllowThreads();
35763 result = (bool)wxClipboardLocker___nonzero__(arg1);
35764 wxPyEndAllowThreads(__tstate);
35765 if (PyErr_Occurred()) SWIG_fail;
35766 }
35767 {
35768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35769 }
35770 return resultobj;
35771 fail:
35772 return NULL;
35773 }
35774
35775
35776 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35777 PyObject *obj;
35778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35779 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35780 return SWIG_Py_Void();
35781 }
35782
35783 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35784 return SWIG_Python_InitShadowInstance(args);
35785 }
35786
35787 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35788 PyObject *resultobj = 0;
35789 int arg1 = (int) 0 ;
35790 int arg2 = (int) 0 ;
35791 int arg3 = (int) 0 ;
35792 int arg4 = (int) 0 ;
35793 wxVideoMode *result = 0 ;
35794 int val1 ;
35795 int ecode1 = 0 ;
35796 int val2 ;
35797 int ecode2 = 0 ;
35798 int val3 ;
35799 int ecode3 = 0 ;
35800 int val4 ;
35801 int ecode4 = 0 ;
35802 PyObject * obj0 = 0 ;
35803 PyObject * obj1 = 0 ;
35804 PyObject * obj2 = 0 ;
35805 PyObject * obj3 = 0 ;
35806 char * kwnames[] = {
35807 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35808 };
35809
35810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35811 if (obj0) {
35812 ecode1 = SWIG_AsVal_int(obj0, &val1);
35813 if (!SWIG_IsOK(ecode1)) {
35814 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35815 }
35816 arg1 = static_cast< int >(val1);
35817 }
35818 if (obj1) {
35819 ecode2 = SWIG_AsVal_int(obj1, &val2);
35820 if (!SWIG_IsOK(ecode2)) {
35821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35822 }
35823 arg2 = static_cast< int >(val2);
35824 }
35825 if (obj2) {
35826 ecode3 = SWIG_AsVal_int(obj2, &val3);
35827 if (!SWIG_IsOK(ecode3)) {
35828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35829 }
35830 arg3 = static_cast< int >(val3);
35831 }
35832 if (obj3) {
35833 ecode4 = SWIG_AsVal_int(obj3, &val4);
35834 if (!SWIG_IsOK(ecode4)) {
35835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35836 }
35837 arg4 = static_cast< int >(val4);
35838 }
35839 {
35840 PyThreadState* __tstate = wxPyBeginAllowThreads();
35841 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35842 wxPyEndAllowThreads(__tstate);
35843 if (PyErr_Occurred()) SWIG_fail;
35844 }
35845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35846 return resultobj;
35847 fail:
35848 return NULL;
35849 }
35850
35851
35852 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35853 PyObject *resultobj = 0;
35854 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35855 void *argp1 = 0 ;
35856 int res1 = 0 ;
35857 PyObject *swig_obj[1] ;
35858
35859 if (!args) SWIG_fail;
35860 swig_obj[0] = args;
35861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35862 if (!SWIG_IsOK(res1)) {
35863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35864 }
35865 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35866 {
35867 PyThreadState* __tstate = wxPyBeginAllowThreads();
35868 delete arg1;
35869
35870 wxPyEndAllowThreads(__tstate);
35871 if (PyErr_Occurred()) SWIG_fail;
35872 }
35873 resultobj = SWIG_Py_Void();
35874 return resultobj;
35875 fail:
35876 return NULL;
35877 }
35878
35879
35880 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35881 PyObject *resultobj = 0;
35882 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35883 wxVideoMode *arg2 = 0 ;
35884 bool result;
35885 void *argp1 = 0 ;
35886 int res1 = 0 ;
35887 void *argp2 = 0 ;
35888 int res2 = 0 ;
35889 PyObject * obj0 = 0 ;
35890 PyObject * obj1 = 0 ;
35891 char * kwnames[] = {
35892 (char *) "self",(char *) "other", NULL
35893 };
35894
35895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35897 if (!SWIG_IsOK(res1)) {
35898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35899 }
35900 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35901 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35902 if (!SWIG_IsOK(res2)) {
35903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35904 }
35905 if (!argp2) {
35906 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35907 }
35908 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35909 {
35910 PyThreadState* __tstate = wxPyBeginAllowThreads();
35911 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35912 wxPyEndAllowThreads(__tstate);
35913 if (PyErr_Occurred()) SWIG_fail;
35914 }
35915 {
35916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35917 }
35918 return resultobj;
35919 fail:
35920 return NULL;
35921 }
35922
35923
35924 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35925 PyObject *resultobj = 0;
35926 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35927 int result;
35928 void *argp1 = 0 ;
35929 int res1 = 0 ;
35930 PyObject *swig_obj[1] ;
35931
35932 if (!args) SWIG_fail;
35933 swig_obj[0] = args;
35934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35935 if (!SWIG_IsOK(res1)) {
35936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35937 }
35938 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35939 {
35940 PyThreadState* __tstate = wxPyBeginAllowThreads();
35941 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35942 wxPyEndAllowThreads(__tstate);
35943 if (PyErr_Occurred()) SWIG_fail;
35944 }
35945 resultobj = SWIG_From_int(static_cast< int >(result));
35946 return resultobj;
35947 fail:
35948 return NULL;
35949 }
35950
35951
35952 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35953 PyObject *resultobj = 0;
35954 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35955 int result;
35956 void *argp1 = 0 ;
35957 int res1 = 0 ;
35958 PyObject *swig_obj[1] ;
35959
35960 if (!args) SWIG_fail;
35961 swig_obj[0] = args;
35962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35963 if (!SWIG_IsOK(res1)) {
35964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35965 }
35966 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35967 {
35968 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35970 wxPyEndAllowThreads(__tstate);
35971 if (PyErr_Occurred()) SWIG_fail;
35972 }
35973 resultobj = SWIG_From_int(static_cast< int >(result));
35974 return resultobj;
35975 fail:
35976 return NULL;
35977 }
35978
35979
35980 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35981 PyObject *resultobj = 0;
35982 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35983 int result;
35984 void *argp1 = 0 ;
35985 int res1 = 0 ;
35986 PyObject *swig_obj[1] ;
35987
35988 if (!args) SWIG_fail;
35989 swig_obj[0] = args;
35990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35991 if (!SWIG_IsOK(res1)) {
35992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35993 }
35994 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35995 {
35996 PyThreadState* __tstate = wxPyBeginAllowThreads();
35997 result = (int)((wxVideoMode const *)arg1)->GetDepth();
35998 wxPyEndAllowThreads(__tstate);
35999 if (PyErr_Occurred()) SWIG_fail;
36000 }
36001 resultobj = SWIG_From_int(static_cast< int >(result));
36002 return resultobj;
36003 fail:
36004 return NULL;
36005 }
36006
36007
36008 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36009 PyObject *resultobj = 0;
36010 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36011 bool result;
36012 void *argp1 = 0 ;
36013 int res1 = 0 ;
36014 PyObject *swig_obj[1] ;
36015
36016 if (!args) SWIG_fail;
36017 swig_obj[0] = args;
36018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36019 if (!SWIG_IsOK(res1)) {
36020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36021 }
36022 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36023 {
36024 PyThreadState* __tstate = wxPyBeginAllowThreads();
36025 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36026 wxPyEndAllowThreads(__tstate);
36027 if (PyErr_Occurred()) SWIG_fail;
36028 }
36029 {
36030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36031 }
36032 return resultobj;
36033 fail:
36034 return NULL;
36035 }
36036
36037
36038 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36039 PyObject *resultobj = 0;
36040 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36041 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36042 bool result;
36043 void *argp1 = 0 ;
36044 int res1 = 0 ;
36045 void *argp2 = 0 ;
36046 int res2 = 0 ;
36047 PyObject * obj0 = 0 ;
36048 PyObject * obj1 = 0 ;
36049 char * kwnames[] = {
36050 (char *) "self",(char *) "other", NULL
36051 };
36052
36053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36055 if (!SWIG_IsOK(res1)) {
36056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36057 }
36058 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36060 if (!SWIG_IsOK(res2)) {
36061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36062 }
36063 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36064 {
36065 PyThreadState* __tstate = wxPyBeginAllowThreads();
36066 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36067 wxPyEndAllowThreads(__tstate);
36068 if (PyErr_Occurred()) SWIG_fail;
36069 }
36070 {
36071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36072 }
36073 return resultobj;
36074 fail:
36075 return NULL;
36076 }
36077
36078
36079 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36080 PyObject *resultobj = 0;
36081 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36082 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36083 bool result;
36084 void *argp1 = 0 ;
36085 int res1 = 0 ;
36086 void *argp2 = 0 ;
36087 int res2 = 0 ;
36088 PyObject * obj0 = 0 ;
36089 PyObject * obj1 = 0 ;
36090 char * kwnames[] = {
36091 (char *) "self",(char *) "other", NULL
36092 };
36093
36094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36096 if (!SWIG_IsOK(res1)) {
36097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36098 }
36099 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36100 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36101 if (!SWIG_IsOK(res2)) {
36102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36103 }
36104 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36105 {
36106 PyThreadState* __tstate = wxPyBeginAllowThreads();
36107 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 {
36112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36113 }
36114 return resultobj;
36115 fail:
36116 return NULL;
36117 }
36118
36119
36120 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36121 PyObject *resultobj = 0;
36122 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36123 int arg2 ;
36124 void *argp1 = 0 ;
36125 int res1 = 0 ;
36126 int val2 ;
36127 int ecode2 = 0 ;
36128 PyObject *swig_obj[2] ;
36129
36130 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36132 if (!SWIG_IsOK(res1)) {
36133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36134 }
36135 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36136 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36137 if (!SWIG_IsOK(ecode2)) {
36138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36139 }
36140 arg2 = static_cast< int >(val2);
36141 if (arg1) (arg1)->w = arg2;
36142
36143 resultobj = SWIG_Py_Void();
36144 return resultobj;
36145 fail:
36146 return NULL;
36147 }
36148
36149
36150 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36151 PyObject *resultobj = 0;
36152 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36153 int result;
36154 void *argp1 = 0 ;
36155 int res1 = 0 ;
36156 PyObject *swig_obj[1] ;
36157
36158 if (!args) SWIG_fail;
36159 swig_obj[0] = args;
36160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36161 if (!SWIG_IsOK(res1)) {
36162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36163 }
36164 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36165 result = (int) ((arg1)->w);
36166 resultobj = SWIG_From_int(static_cast< int >(result));
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36174 PyObject *resultobj = 0;
36175 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36176 int arg2 ;
36177 void *argp1 = 0 ;
36178 int res1 = 0 ;
36179 int val2 ;
36180 int ecode2 = 0 ;
36181 PyObject *swig_obj[2] ;
36182
36183 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36185 if (!SWIG_IsOK(res1)) {
36186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36187 }
36188 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36189 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36190 if (!SWIG_IsOK(ecode2)) {
36191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36192 }
36193 arg2 = static_cast< int >(val2);
36194 if (arg1) (arg1)->h = arg2;
36195
36196 resultobj = SWIG_Py_Void();
36197 return resultobj;
36198 fail:
36199 return NULL;
36200 }
36201
36202
36203 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36204 PyObject *resultobj = 0;
36205 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36206 int result;
36207 void *argp1 = 0 ;
36208 int res1 = 0 ;
36209 PyObject *swig_obj[1] ;
36210
36211 if (!args) SWIG_fail;
36212 swig_obj[0] = args;
36213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36214 if (!SWIG_IsOK(res1)) {
36215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36216 }
36217 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36218 result = (int) ((arg1)->h);
36219 resultobj = SWIG_From_int(static_cast< int >(result));
36220 return resultobj;
36221 fail:
36222 return NULL;
36223 }
36224
36225
36226 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36227 PyObject *resultobj = 0;
36228 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36229 int arg2 ;
36230 void *argp1 = 0 ;
36231 int res1 = 0 ;
36232 int val2 ;
36233 int ecode2 = 0 ;
36234 PyObject *swig_obj[2] ;
36235
36236 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36238 if (!SWIG_IsOK(res1)) {
36239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36240 }
36241 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36242 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36243 if (!SWIG_IsOK(ecode2)) {
36244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36245 }
36246 arg2 = static_cast< int >(val2);
36247 if (arg1) (arg1)->bpp = arg2;
36248
36249 resultobj = SWIG_Py_Void();
36250 return resultobj;
36251 fail:
36252 return NULL;
36253 }
36254
36255
36256 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36257 PyObject *resultobj = 0;
36258 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36259 int result;
36260 void *argp1 = 0 ;
36261 int res1 = 0 ;
36262 PyObject *swig_obj[1] ;
36263
36264 if (!args) SWIG_fail;
36265 swig_obj[0] = args;
36266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36267 if (!SWIG_IsOK(res1)) {
36268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36269 }
36270 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36271 result = (int) ((arg1)->bpp);
36272 resultobj = SWIG_From_int(static_cast< int >(result));
36273 return resultobj;
36274 fail:
36275 return NULL;
36276 }
36277
36278
36279 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36280 PyObject *resultobj = 0;
36281 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36282 int arg2 ;
36283 void *argp1 = 0 ;
36284 int res1 = 0 ;
36285 int val2 ;
36286 int ecode2 = 0 ;
36287 PyObject *swig_obj[2] ;
36288
36289 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36291 if (!SWIG_IsOK(res1)) {
36292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36293 }
36294 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36295 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36296 if (!SWIG_IsOK(ecode2)) {
36297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36298 }
36299 arg2 = static_cast< int >(val2);
36300 if (arg1) (arg1)->refresh = arg2;
36301
36302 resultobj = SWIG_Py_Void();
36303 return resultobj;
36304 fail:
36305 return NULL;
36306 }
36307
36308
36309 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36310 PyObject *resultobj = 0;
36311 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36312 int result;
36313 void *argp1 = 0 ;
36314 int res1 = 0 ;
36315 PyObject *swig_obj[1] ;
36316
36317 if (!args) SWIG_fail;
36318 swig_obj[0] = args;
36319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36320 if (!SWIG_IsOK(res1)) {
36321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36322 }
36323 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36324 result = (int) ((arg1)->refresh);
36325 resultobj = SWIG_From_int(static_cast< int >(result));
36326 return resultobj;
36327 fail:
36328 return NULL;
36329 }
36330
36331
36332 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36333 PyObject *obj;
36334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36335 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36336 return SWIG_Py_Void();
36337 }
36338
36339 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36340 return SWIG_Python_InitShadowInstance(args);
36341 }
36342
36343 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36344 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36345 return 1;
36346 }
36347
36348
36349 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36350 PyObject *pyobj = 0;
36351
36352 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36353 return pyobj;
36354 }
36355
36356
36357 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36358 PyObject *resultobj = 0;
36359 unsigned int arg1 = (unsigned int) 0 ;
36360 wxDisplay *result = 0 ;
36361 unsigned int val1 ;
36362 int ecode1 = 0 ;
36363 PyObject * obj0 = 0 ;
36364 char * kwnames[] = {
36365 (char *) "index", NULL
36366 };
36367
36368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36369 if (obj0) {
36370 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36371 if (!SWIG_IsOK(ecode1)) {
36372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36373 }
36374 arg1 = static_cast< unsigned int >(val1);
36375 }
36376 {
36377 PyThreadState* __tstate = wxPyBeginAllowThreads();
36378 result = (wxDisplay *)new wxDisplay(arg1);
36379 wxPyEndAllowThreads(__tstate);
36380 if (PyErr_Occurred()) SWIG_fail;
36381 }
36382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36383 return resultobj;
36384 fail:
36385 return NULL;
36386 }
36387
36388
36389 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36390 PyObject *resultobj = 0;
36391 wxDisplay *arg1 = (wxDisplay *) 0 ;
36392 void *argp1 = 0 ;
36393 int res1 = 0 ;
36394 PyObject *swig_obj[1] ;
36395
36396 if (!args) SWIG_fail;
36397 swig_obj[0] = args;
36398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36399 if (!SWIG_IsOK(res1)) {
36400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36401 }
36402 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 delete arg1;
36406
36407 wxPyEndAllowThreads(__tstate);
36408 if (PyErr_Occurred()) SWIG_fail;
36409 }
36410 resultobj = SWIG_Py_Void();
36411 return resultobj;
36412 fail:
36413 return NULL;
36414 }
36415
36416
36417 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36418 PyObject *resultobj = 0;
36419 unsigned int result;
36420
36421 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36422 {
36423 PyThreadState* __tstate = wxPyBeginAllowThreads();
36424 result = (unsigned int)wxDisplay::GetCount();
36425 wxPyEndAllowThreads(__tstate);
36426 if (PyErr_Occurred()) SWIG_fail;
36427 }
36428 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36429 return resultobj;
36430 fail:
36431 return NULL;
36432 }
36433
36434
36435 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36436 PyObject *resultobj = 0;
36437 wxPoint *arg1 = 0 ;
36438 int result;
36439 wxPoint temp1 ;
36440 PyObject * obj0 = 0 ;
36441 char * kwnames[] = {
36442 (char *) "pt", NULL
36443 };
36444
36445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36446 {
36447 arg1 = &temp1;
36448 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36449 }
36450 {
36451 PyThreadState* __tstate = wxPyBeginAllowThreads();
36452 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36453 wxPyEndAllowThreads(__tstate);
36454 if (PyErr_Occurred()) SWIG_fail;
36455 }
36456 resultobj = SWIG_From_int(static_cast< int >(result));
36457 return resultobj;
36458 fail:
36459 return NULL;
36460 }
36461
36462
36463 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36464 PyObject *resultobj = 0;
36465 wxWindow *arg1 = (wxWindow *) 0 ;
36466 int result;
36467 void *argp1 = 0 ;
36468 int res1 = 0 ;
36469 PyObject * obj0 = 0 ;
36470 char * kwnames[] = {
36471 (char *) "window", NULL
36472 };
36473
36474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36476 if (!SWIG_IsOK(res1)) {
36477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36478 }
36479 arg1 = reinterpret_cast< wxWindow * >(argp1);
36480 {
36481 PyThreadState* __tstate = wxPyBeginAllowThreads();
36482 result = (int)wxDisplay::GetFromWindow(arg1);
36483 wxPyEndAllowThreads(__tstate);
36484 if (PyErr_Occurred()) SWIG_fail;
36485 }
36486 resultobj = SWIG_From_int(static_cast< int >(result));
36487 return resultobj;
36488 fail:
36489 return NULL;
36490 }
36491
36492
36493 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36494 PyObject *resultobj = 0;
36495 wxDisplay *arg1 = (wxDisplay *) 0 ;
36496 bool result;
36497 void *argp1 = 0 ;
36498 int res1 = 0 ;
36499 PyObject *swig_obj[1] ;
36500
36501 if (!args) SWIG_fail;
36502 swig_obj[0] = args;
36503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36504 if (!SWIG_IsOK(res1)) {
36505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36506 }
36507 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36508 {
36509 PyThreadState* __tstate = wxPyBeginAllowThreads();
36510 result = (bool)((wxDisplay const *)arg1)->IsOk();
36511 wxPyEndAllowThreads(__tstate);
36512 if (PyErr_Occurred()) SWIG_fail;
36513 }
36514 {
36515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36516 }
36517 return resultobj;
36518 fail:
36519 return NULL;
36520 }
36521
36522
36523 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36524 PyObject *resultobj = 0;
36525 wxDisplay *arg1 = (wxDisplay *) 0 ;
36526 wxRect result;
36527 void *argp1 = 0 ;
36528 int res1 = 0 ;
36529 PyObject *swig_obj[1] ;
36530
36531 if (!args) SWIG_fail;
36532 swig_obj[0] = args;
36533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36534 if (!SWIG_IsOK(res1)) {
36535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36536 }
36537 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36538 {
36539 PyThreadState* __tstate = wxPyBeginAllowThreads();
36540 result = ((wxDisplay const *)arg1)->GetGeometry();
36541 wxPyEndAllowThreads(__tstate);
36542 if (PyErr_Occurred()) SWIG_fail;
36543 }
36544 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36545 return resultobj;
36546 fail:
36547 return NULL;
36548 }
36549
36550
36551 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36552 PyObject *resultobj = 0;
36553 wxDisplay *arg1 = (wxDisplay *) 0 ;
36554 wxRect result;
36555 void *argp1 = 0 ;
36556 int res1 = 0 ;
36557 PyObject *swig_obj[1] ;
36558
36559 if (!args) SWIG_fail;
36560 swig_obj[0] = args;
36561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36562 if (!SWIG_IsOK(res1)) {
36563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36564 }
36565 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36566 {
36567 PyThreadState* __tstate = wxPyBeginAllowThreads();
36568 result = ((wxDisplay const *)arg1)->GetClientArea();
36569 wxPyEndAllowThreads(__tstate);
36570 if (PyErr_Occurred()) SWIG_fail;
36571 }
36572 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36573 return resultobj;
36574 fail:
36575 return NULL;
36576 }
36577
36578
36579 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36580 PyObject *resultobj = 0;
36581 wxDisplay *arg1 = (wxDisplay *) 0 ;
36582 wxString result;
36583 void *argp1 = 0 ;
36584 int res1 = 0 ;
36585 PyObject *swig_obj[1] ;
36586
36587 if (!args) SWIG_fail;
36588 swig_obj[0] = args;
36589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36590 if (!SWIG_IsOK(res1)) {
36591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36592 }
36593 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36594 {
36595 PyThreadState* __tstate = wxPyBeginAllowThreads();
36596 result = ((wxDisplay const *)arg1)->GetName();
36597 wxPyEndAllowThreads(__tstate);
36598 if (PyErr_Occurred()) SWIG_fail;
36599 }
36600 {
36601 #if wxUSE_UNICODE
36602 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36603 #else
36604 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36605 #endif
36606 }
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36614 PyObject *resultobj = 0;
36615 wxDisplay *arg1 = (wxDisplay *) 0 ;
36616 bool result;
36617 void *argp1 = 0 ;
36618 int res1 = 0 ;
36619 PyObject *swig_obj[1] ;
36620
36621 if (!args) SWIG_fail;
36622 swig_obj[0] = args;
36623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36624 if (!SWIG_IsOK(res1)) {
36625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36626 }
36627 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36628 {
36629 PyThreadState* __tstate = wxPyBeginAllowThreads();
36630 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36631 wxPyEndAllowThreads(__tstate);
36632 if (PyErr_Occurred()) SWIG_fail;
36633 }
36634 {
36635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36636 }
36637 return resultobj;
36638 fail:
36639 return NULL;
36640 }
36641
36642
36643 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36644 PyObject *resultobj = 0;
36645 wxDisplay *arg1 = (wxDisplay *) 0 ;
36646 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36647 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36648 PyObject *result = 0 ;
36649 void *argp1 = 0 ;
36650 int res1 = 0 ;
36651 void *argp2 = 0 ;
36652 int res2 = 0 ;
36653 PyObject * obj0 = 0 ;
36654 PyObject * obj1 = 0 ;
36655 char * kwnames[] = {
36656 (char *) "self",(char *) "mode", NULL
36657 };
36658
36659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36661 if (!SWIG_IsOK(res1)) {
36662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36663 }
36664 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36665 if (obj1) {
36666 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36667 if (!SWIG_IsOK(res2)) {
36668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36669 }
36670 if (!argp2) {
36671 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36672 }
36673 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36674 }
36675 {
36676 PyThreadState* __tstate = wxPyBeginAllowThreads();
36677 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36678 wxPyEndAllowThreads(__tstate);
36679 if (PyErr_Occurred()) SWIG_fail;
36680 }
36681 resultobj = result;
36682 return resultobj;
36683 fail:
36684 return NULL;
36685 }
36686
36687
36688 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36689 PyObject *resultobj = 0;
36690 wxDisplay *arg1 = (wxDisplay *) 0 ;
36691 wxVideoMode result;
36692 void *argp1 = 0 ;
36693 int res1 = 0 ;
36694 PyObject *swig_obj[1] ;
36695
36696 if (!args) SWIG_fail;
36697 swig_obj[0] = args;
36698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36699 if (!SWIG_IsOK(res1)) {
36700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36701 }
36702 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36703 {
36704 PyThreadState* __tstate = wxPyBeginAllowThreads();
36705 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36706 wxPyEndAllowThreads(__tstate);
36707 if (PyErr_Occurred()) SWIG_fail;
36708 }
36709 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36710 return resultobj;
36711 fail:
36712 return NULL;
36713 }
36714
36715
36716 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36717 PyObject *resultobj = 0;
36718 wxDisplay *arg1 = (wxDisplay *) 0 ;
36719 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36720 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36721 bool result;
36722 void *argp1 = 0 ;
36723 int res1 = 0 ;
36724 void *argp2 = 0 ;
36725 int res2 = 0 ;
36726 PyObject * obj0 = 0 ;
36727 PyObject * obj1 = 0 ;
36728 char * kwnames[] = {
36729 (char *) "self",(char *) "mode", NULL
36730 };
36731
36732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36734 if (!SWIG_IsOK(res1)) {
36735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36736 }
36737 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36738 if (obj1) {
36739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36740 if (!SWIG_IsOK(res2)) {
36741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36742 }
36743 if (!argp2) {
36744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36745 }
36746 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36747 }
36748 {
36749 PyThreadState* __tstate = wxPyBeginAllowThreads();
36750 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36751 wxPyEndAllowThreads(__tstate);
36752 if (PyErr_Occurred()) SWIG_fail;
36753 }
36754 {
36755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36756 }
36757 return resultobj;
36758 fail:
36759 return NULL;
36760 }
36761
36762
36763 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36764 PyObject *resultobj = 0;
36765 wxDisplay *arg1 = (wxDisplay *) 0 ;
36766 void *argp1 = 0 ;
36767 int res1 = 0 ;
36768 PyObject *swig_obj[1] ;
36769
36770 if (!args) SWIG_fail;
36771 swig_obj[0] = args;
36772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36773 if (!SWIG_IsOK(res1)) {
36774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36775 }
36776 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36777 {
36778 PyThreadState* __tstate = wxPyBeginAllowThreads();
36779 wxDisplay_ResetMode(arg1);
36780 wxPyEndAllowThreads(__tstate);
36781 if (PyErr_Occurred()) SWIG_fail;
36782 }
36783 resultobj = SWIG_Py_Void();
36784 return resultobj;
36785 fail:
36786 return NULL;
36787 }
36788
36789
36790 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36791 PyObject *obj;
36792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36793 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36794 return SWIG_Py_Void();
36795 }
36796
36797 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36798 return SWIG_Python_InitShadowInstance(args);
36799 }
36800
36801 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36802 PyObject *resultobj = 0;
36803 wxStandardPaths *result = 0 ;
36804
36805 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36806 {
36807 PyThreadState* __tstate = wxPyBeginAllowThreads();
36808 result = (wxStandardPaths *)wxStandardPaths_Get();
36809 wxPyEndAllowThreads(__tstate);
36810 if (PyErr_Occurred()) SWIG_fail;
36811 }
36812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36813 return resultobj;
36814 fail:
36815 return NULL;
36816 }
36817
36818
36819 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36820 PyObject *resultobj = 0;
36821 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36822 wxString result;
36823 void *argp1 = 0 ;
36824 int res1 = 0 ;
36825 PyObject *swig_obj[1] ;
36826
36827 if (!args) SWIG_fail;
36828 swig_obj[0] = args;
36829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36830 if (!SWIG_IsOK(res1)) {
36831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36832 }
36833 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36834 {
36835 PyThreadState* __tstate = wxPyBeginAllowThreads();
36836 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36837 wxPyEndAllowThreads(__tstate);
36838 if (PyErr_Occurred()) SWIG_fail;
36839 }
36840 {
36841 #if wxUSE_UNICODE
36842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36843 #else
36844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36845 #endif
36846 }
36847 return resultobj;
36848 fail:
36849 return NULL;
36850 }
36851
36852
36853 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36854 PyObject *resultobj = 0;
36855 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36856 wxString result;
36857 void *argp1 = 0 ;
36858 int res1 = 0 ;
36859 PyObject *swig_obj[1] ;
36860
36861 if (!args) SWIG_fail;
36862 swig_obj[0] = args;
36863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36864 if (!SWIG_IsOK(res1)) {
36865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36866 }
36867 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36871 wxPyEndAllowThreads(__tstate);
36872 if (PyErr_Occurred()) SWIG_fail;
36873 }
36874 {
36875 #if wxUSE_UNICODE
36876 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36877 #else
36878 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36879 #endif
36880 }
36881 return resultobj;
36882 fail:
36883 return NULL;
36884 }
36885
36886
36887 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36888 PyObject *resultobj = 0;
36889 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36890 wxString result;
36891 void *argp1 = 0 ;
36892 int res1 = 0 ;
36893 PyObject *swig_obj[1] ;
36894
36895 if (!args) SWIG_fail;
36896 swig_obj[0] = args;
36897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36898 if (!SWIG_IsOK(res1)) {
36899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36900 }
36901 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36902 {
36903 PyThreadState* __tstate = wxPyBeginAllowThreads();
36904 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36905 wxPyEndAllowThreads(__tstate);
36906 if (PyErr_Occurred()) SWIG_fail;
36907 }
36908 {
36909 #if wxUSE_UNICODE
36910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36911 #else
36912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36913 #endif
36914 }
36915 return resultobj;
36916 fail:
36917 return NULL;
36918 }
36919
36920
36921 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36922 PyObject *resultobj = 0;
36923 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36924 wxString result;
36925 void *argp1 = 0 ;
36926 int res1 = 0 ;
36927 PyObject *swig_obj[1] ;
36928
36929 if (!args) SWIG_fail;
36930 swig_obj[0] = args;
36931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36932 if (!SWIG_IsOK(res1)) {
36933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36934 }
36935 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36936 {
36937 PyThreadState* __tstate = wxPyBeginAllowThreads();
36938 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36939 wxPyEndAllowThreads(__tstate);
36940 if (PyErr_Occurred()) SWIG_fail;
36941 }
36942 {
36943 #if wxUSE_UNICODE
36944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36945 #else
36946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36947 #endif
36948 }
36949 return resultobj;
36950 fail:
36951 return NULL;
36952 }
36953
36954
36955 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36956 PyObject *resultobj = 0;
36957 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36958 wxString result;
36959 void *argp1 = 0 ;
36960 int res1 = 0 ;
36961 PyObject *swig_obj[1] ;
36962
36963 if (!args) SWIG_fail;
36964 swig_obj[0] = args;
36965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36966 if (!SWIG_IsOK(res1)) {
36967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36968 }
36969 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36970 {
36971 PyThreadState* __tstate = wxPyBeginAllowThreads();
36972 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36973 wxPyEndAllowThreads(__tstate);
36974 if (PyErr_Occurred()) SWIG_fail;
36975 }
36976 {
36977 #if wxUSE_UNICODE
36978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36979 #else
36980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36981 #endif
36982 }
36983 return resultobj;
36984 fail:
36985 return NULL;
36986 }
36987
36988
36989 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36990 PyObject *resultobj = 0;
36991 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36992 wxString result;
36993 void *argp1 = 0 ;
36994 int res1 = 0 ;
36995 PyObject *swig_obj[1] ;
36996
36997 if (!args) SWIG_fail;
36998 swig_obj[0] = args;
36999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37000 if (!SWIG_IsOK(res1)) {
37001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37002 }
37003 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37004 {
37005 PyThreadState* __tstate = wxPyBeginAllowThreads();
37006 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37007 wxPyEndAllowThreads(__tstate);
37008 if (PyErr_Occurred()) SWIG_fail;
37009 }
37010 {
37011 #if wxUSE_UNICODE
37012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37013 #else
37014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37015 #endif
37016 }
37017 return resultobj;
37018 fail:
37019 return NULL;
37020 }
37021
37022
37023 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37024 PyObject *resultobj = 0;
37025 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37026 wxString result;
37027 void *argp1 = 0 ;
37028 int res1 = 0 ;
37029 PyObject *swig_obj[1] ;
37030
37031 if (!args) SWIG_fail;
37032 swig_obj[0] = args;
37033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37034 if (!SWIG_IsOK(res1)) {
37035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37036 }
37037 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37038 {
37039 PyThreadState* __tstate = wxPyBeginAllowThreads();
37040 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37041 wxPyEndAllowThreads(__tstate);
37042 if (PyErr_Occurred()) SWIG_fail;
37043 }
37044 {
37045 #if wxUSE_UNICODE
37046 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37047 #else
37048 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37049 #endif
37050 }
37051 return resultobj;
37052 fail:
37053 return NULL;
37054 }
37055
37056
37057 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37058 PyObject *resultobj = 0;
37059 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37060 wxString result;
37061 void *argp1 = 0 ;
37062 int res1 = 0 ;
37063 PyObject *swig_obj[1] ;
37064
37065 if (!args) SWIG_fail;
37066 swig_obj[0] = args;
37067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37068 if (!SWIG_IsOK(res1)) {
37069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37070 }
37071 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37072 {
37073 PyThreadState* __tstate = wxPyBeginAllowThreads();
37074 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37075 wxPyEndAllowThreads(__tstate);
37076 if (PyErr_Occurred()) SWIG_fail;
37077 }
37078 {
37079 #if wxUSE_UNICODE
37080 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37081 #else
37082 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37083 #endif
37084 }
37085 return resultobj;
37086 fail:
37087 return NULL;
37088 }
37089
37090
37091 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37092 PyObject *resultobj = 0;
37093 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37094 wxString *arg2 = 0 ;
37095 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37096 wxString result;
37097 void *argp1 = 0 ;
37098 int res1 = 0 ;
37099 bool temp2 = false ;
37100 int val3 ;
37101 int ecode3 = 0 ;
37102 PyObject * obj0 = 0 ;
37103 PyObject * obj1 = 0 ;
37104 PyObject * obj2 = 0 ;
37105 char * kwnames[] = {
37106 (char *) "self",(char *) "lang",(char *) "category", NULL
37107 };
37108
37109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37111 if (!SWIG_IsOK(res1)) {
37112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37113 }
37114 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37115 {
37116 arg2 = wxString_in_helper(obj1);
37117 if (arg2 == NULL) SWIG_fail;
37118 temp2 = true;
37119 }
37120 if (obj2) {
37121 ecode3 = SWIG_AsVal_int(obj2, &val3);
37122 if (!SWIG_IsOK(ecode3)) {
37123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37124 }
37125 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37126 }
37127 {
37128 PyThreadState* __tstate = wxPyBeginAllowThreads();
37129 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37130 wxPyEndAllowThreads(__tstate);
37131 if (PyErr_Occurred()) SWIG_fail;
37132 }
37133 {
37134 #if wxUSE_UNICODE
37135 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37136 #else
37137 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37138 #endif
37139 }
37140 {
37141 if (temp2)
37142 delete arg2;
37143 }
37144 return resultobj;
37145 fail:
37146 {
37147 if (temp2)
37148 delete arg2;
37149 }
37150 return NULL;
37151 }
37152
37153
37154 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37155 PyObject *resultobj = 0;
37156 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37157 wxString result;
37158 void *argp1 = 0 ;
37159 int res1 = 0 ;
37160 PyObject *swig_obj[1] ;
37161
37162 if (!args) SWIG_fail;
37163 swig_obj[0] = args;
37164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37165 if (!SWIG_IsOK(res1)) {
37166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37167 }
37168 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37169 {
37170 PyThreadState* __tstate = wxPyBeginAllowThreads();
37171 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37172 wxPyEndAllowThreads(__tstate);
37173 if (PyErr_Occurred()) SWIG_fail;
37174 }
37175 {
37176 #if wxUSE_UNICODE
37177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37178 #else
37179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37180 #endif
37181 }
37182 return resultobj;
37183 fail:
37184 return NULL;
37185 }
37186
37187
37188 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37189 PyObject *resultobj = 0;
37190 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37191 wxString *arg2 = 0 ;
37192 void *argp1 = 0 ;
37193 int res1 = 0 ;
37194 bool temp2 = false ;
37195 PyObject * obj0 = 0 ;
37196 PyObject * obj1 = 0 ;
37197 char * kwnames[] = {
37198 (char *) "self",(char *) "prefix", NULL
37199 };
37200
37201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37203 if (!SWIG_IsOK(res1)) {
37204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37205 }
37206 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37207 {
37208 arg2 = wxString_in_helper(obj1);
37209 if (arg2 == NULL) SWIG_fail;
37210 temp2 = true;
37211 }
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 resultobj = SWIG_Py_Void();
37219 {
37220 if (temp2)
37221 delete arg2;
37222 }
37223 return resultobj;
37224 fail:
37225 {
37226 if (temp2)
37227 delete arg2;
37228 }
37229 return NULL;
37230 }
37231
37232
37233 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37234 PyObject *resultobj = 0;
37235 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37236 wxString result;
37237 void *argp1 = 0 ;
37238 int res1 = 0 ;
37239 PyObject *swig_obj[1] ;
37240
37241 if (!args) SWIG_fail;
37242 swig_obj[0] = args;
37243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37244 if (!SWIG_IsOK(res1)) {
37245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37246 }
37247 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37248 {
37249 PyThreadState* __tstate = wxPyBeginAllowThreads();
37250 result = wxStandardPaths_GetInstallPrefix(arg1);
37251 wxPyEndAllowThreads(__tstate);
37252 if (PyErr_Occurred()) SWIG_fail;
37253 }
37254 {
37255 #if wxUSE_UNICODE
37256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37257 #else
37258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37259 #endif
37260 }
37261 return resultobj;
37262 fail:
37263 return NULL;
37264 }
37265
37266
37267 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37268 PyObject *obj;
37269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37270 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37271 return SWIG_Py_Void();
37272 }
37273
37274 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37275 PyObject *resultobj = 0;
37276 wxEventType arg1 ;
37277 wxPowerEvent *result = 0 ;
37278 int val1 ;
37279 int ecode1 = 0 ;
37280 PyObject * obj0 = 0 ;
37281 char * kwnames[] = {
37282 (char *) "evtType", NULL
37283 };
37284
37285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37286 ecode1 = SWIG_AsVal_int(obj0, &val1);
37287 if (!SWIG_IsOK(ecode1)) {
37288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37289 }
37290 arg1 = static_cast< wxEventType >(val1);
37291 {
37292 PyThreadState* __tstate = wxPyBeginAllowThreads();
37293 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37294 wxPyEndAllowThreads(__tstate);
37295 if (PyErr_Occurred()) SWIG_fail;
37296 }
37297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37298 return resultobj;
37299 fail:
37300 return NULL;
37301 }
37302
37303
37304 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37305 PyObject *resultobj = 0;
37306 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37307 void *argp1 = 0 ;
37308 int res1 = 0 ;
37309 PyObject *swig_obj[1] ;
37310
37311 if (!args) SWIG_fail;
37312 swig_obj[0] = args;
37313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37314 if (!SWIG_IsOK(res1)) {
37315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37316 }
37317 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37318 {
37319 PyThreadState* __tstate = wxPyBeginAllowThreads();
37320 (arg1)->Veto();
37321 wxPyEndAllowThreads(__tstate);
37322 if (PyErr_Occurred()) SWIG_fail;
37323 }
37324 resultobj = SWIG_Py_Void();
37325 return resultobj;
37326 fail:
37327 return NULL;
37328 }
37329
37330
37331 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37332 PyObject *resultobj = 0;
37333 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37334 bool result;
37335 void *argp1 = 0 ;
37336 int res1 = 0 ;
37337 PyObject *swig_obj[1] ;
37338
37339 if (!args) SWIG_fail;
37340 swig_obj[0] = args;
37341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37342 if (!SWIG_IsOK(res1)) {
37343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37344 }
37345 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37346 {
37347 PyThreadState* __tstate = wxPyBeginAllowThreads();
37348 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37349 wxPyEndAllowThreads(__tstate);
37350 if (PyErr_Occurred()) SWIG_fail;
37351 }
37352 {
37353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37354 }
37355 return resultobj;
37356 fail:
37357 return NULL;
37358 }
37359
37360
37361 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37362 PyObject *obj;
37363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37364 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37365 return SWIG_Py_Void();
37366 }
37367
37368 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37369 return SWIG_Python_InitShadowInstance(args);
37370 }
37371
37372 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37373 PyObject *resultobj = 0;
37374 wxPowerType result;
37375
37376 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37377 {
37378 PyThreadState* __tstate = wxPyBeginAllowThreads();
37379 result = (wxPowerType)wxGetPowerType();
37380 wxPyEndAllowThreads(__tstate);
37381 if (PyErr_Occurred()) SWIG_fail;
37382 }
37383 resultobj = SWIG_From_int(static_cast< int >(result));
37384 return resultobj;
37385 fail:
37386 return NULL;
37387 }
37388
37389
37390 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37391 PyObject *resultobj = 0;
37392 wxBatteryState result;
37393
37394 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37395 {
37396 PyThreadState* __tstate = wxPyBeginAllowThreads();
37397 result = (wxBatteryState)wxGetBatteryState();
37398 wxPyEndAllowThreads(__tstate);
37399 if (PyErr_Occurred()) SWIG_fail;
37400 }
37401 resultobj = SWIG_From_int(static_cast< int >(result));
37402 return resultobj;
37403 fail:
37404 return NULL;
37405 }
37406
37407
37408 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37409 PyObject *resultobj = 0;
37410 wxAboutDialogInfo *result = 0 ;
37411
37412 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37413 {
37414 PyThreadState* __tstate = wxPyBeginAllowThreads();
37415 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37416 wxPyEndAllowThreads(__tstate);
37417 if (PyErr_Occurred()) SWIG_fail;
37418 }
37419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37420 return resultobj;
37421 fail:
37422 return NULL;
37423 }
37424
37425
37426 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37427 PyObject *resultobj = 0;
37428 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37429 void *argp1 = 0 ;
37430 int res1 = 0 ;
37431 PyObject *swig_obj[1] ;
37432
37433 if (!args) SWIG_fail;
37434 swig_obj[0] = args;
37435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37436 if (!SWIG_IsOK(res1)) {
37437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37438 }
37439 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37440 {
37441 PyThreadState* __tstate = wxPyBeginAllowThreads();
37442 delete arg1;
37443
37444 wxPyEndAllowThreads(__tstate);
37445 if (PyErr_Occurred()) SWIG_fail;
37446 }
37447 resultobj = SWIG_Py_Void();
37448 return resultobj;
37449 fail:
37450 return NULL;
37451 }
37452
37453
37454 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37455 PyObject *resultobj = 0;
37456 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37457 wxString *arg2 = 0 ;
37458 void *argp1 = 0 ;
37459 int res1 = 0 ;
37460 bool temp2 = false ;
37461 PyObject * obj0 = 0 ;
37462 PyObject * obj1 = 0 ;
37463 char * kwnames[] = {
37464 (char *) "self",(char *) "name", NULL
37465 };
37466
37467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37469 if (!SWIG_IsOK(res1)) {
37470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37471 }
37472 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37473 {
37474 arg2 = wxString_in_helper(obj1);
37475 if (arg2 == NULL) SWIG_fail;
37476 temp2 = true;
37477 }
37478 {
37479 PyThreadState* __tstate = wxPyBeginAllowThreads();
37480 (arg1)->SetName((wxString const &)*arg2);
37481 wxPyEndAllowThreads(__tstate);
37482 if (PyErr_Occurred()) SWIG_fail;
37483 }
37484 resultobj = SWIG_Py_Void();
37485 {
37486 if (temp2)
37487 delete arg2;
37488 }
37489 return resultobj;
37490 fail:
37491 {
37492 if (temp2)
37493 delete arg2;
37494 }
37495 return NULL;
37496 }
37497
37498
37499 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37500 PyObject *resultobj = 0;
37501 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37502 wxString result;
37503 void *argp1 = 0 ;
37504 int res1 = 0 ;
37505 PyObject *swig_obj[1] ;
37506
37507 if (!args) SWIG_fail;
37508 swig_obj[0] = args;
37509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37510 if (!SWIG_IsOK(res1)) {
37511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37512 }
37513 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37514 {
37515 PyThreadState* __tstate = wxPyBeginAllowThreads();
37516 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 {
37521 #if wxUSE_UNICODE
37522 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37523 #else
37524 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37525 #endif
37526 }
37527 return resultobj;
37528 fail:
37529 return NULL;
37530 }
37531
37532
37533 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37534 PyObject *resultobj = 0;
37535 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37536 wxString *arg2 = 0 ;
37537 void *argp1 = 0 ;
37538 int res1 = 0 ;
37539 bool temp2 = false ;
37540 PyObject * obj0 = 0 ;
37541 PyObject * obj1 = 0 ;
37542 char * kwnames[] = {
37543 (char *) "self",(char *) "version", NULL
37544 };
37545
37546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37548 if (!SWIG_IsOK(res1)) {
37549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37550 }
37551 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37552 {
37553 arg2 = wxString_in_helper(obj1);
37554 if (arg2 == NULL) SWIG_fail;
37555 temp2 = true;
37556 }
37557 {
37558 PyThreadState* __tstate = wxPyBeginAllowThreads();
37559 (arg1)->SetVersion((wxString const &)*arg2);
37560 wxPyEndAllowThreads(__tstate);
37561 if (PyErr_Occurred()) SWIG_fail;
37562 }
37563 resultobj = SWIG_Py_Void();
37564 {
37565 if (temp2)
37566 delete arg2;
37567 }
37568 return resultobj;
37569 fail:
37570 {
37571 if (temp2)
37572 delete arg2;
37573 }
37574 return NULL;
37575 }
37576
37577
37578 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37579 PyObject *resultobj = 0;
37580 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37581 bool result;
37582 void *argp1 = 0 ;
37583 int res1 = 0 ;
37584 PyObject *swig_obj[1] ;
37585
37586 if (!args) SWIG_fail;
37587 swig_obj[0] = args;
37588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37589 if (!SWIG_IsOK(res1)) {
37590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37591 }
37592 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37593 {
37594 PyThreadState* __tstate = wxPyBeginAllowThreads();
37595 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37596 wxPyEndAllowThreads(__tstate);
37597 if (PyErr_Occurred()) SWIG_fail;
37598 }
37599 {
37600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37601 }
37602 return resultobj;
37603 fail:
37604 return NULL;
37605 }
37606
37607
37608 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37609 PyObject *resultobj = 0;
37610 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37611 wxString result;
37612 void *argp1 = 0 ;
37613 int res1 = 0 ;
37614 PyObject *swig_obj[1] ;
37615
37616 if (!args) SWIG_fail;
37617 swig_obj[0] = args;
37618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37619 if (!SWIG_IsOK(res1)) {
37620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37621 }
37622 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37623 {
37624 PyThreadState* __tstate = wxPyBeginAllowThreads();
37625 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37626 wxPyEndAllowThreads(__tstate);
37627 if (PyErr_Occurred()) SWIG_fail;
37628 }
37629 {
37630 #if wxUSE_UNICODE
37631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37632 #else
37633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37634 #endif
37635 }
37636 return resultobj;
37637 fail:
37638 return NULL;
37639 }
37640
37641
37642 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37643 PyObject *resultobj = 0;
37644 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37645 wxString *arg2 = 0 ;
37646 void *argp1 = 0 ;
37647 int res1 = 0 ;
37648 bool temp2 = false ;
37649 PyObject * obj0 = 0 ;
37650 PyObject * obj1 = 0 ;
37651 char * kwnames[] = {
37652 (char *) "self",(char *) "desc", NULL
37653 };
37654
37655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37657 if (!SWIG_IsOK(res1)) {
37658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37659 }
37660 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37661 {
37662 arg2 = wxString_in_helper(obj1);
37663 if (arg2 == NULL) SWIG_fail;
37664 temp2 = true;
37665 }
37666 {
37667 PyThreadState* __tstate = wxPyBeginAllowThreads();
37668 (arg1)->SetDescription((wxString const &)*arg2);
37669 wxPyEndAllowThreads(__tstate);
37670 if (PyErr_Occurred()) SWIG_fail;
37671 }
37672 resultobj = SWIG_Py_Void();
37673 {
37674 if (temp2)
37675 delete arg2;
37676 }
37677 return resultobj;
37678 fail:
37679 {
37680 if (temp2)
37681 delete arg2;
37682 }
37683 return NULL;
37684 }
37685
37686
37687 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37688 PyObject *resultobj = 0;
37689 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37690 bool result;
37691 void *argp1 = 0 ;
37692 int res1 = 0 ;
37693 PyObject *swig_obj[1] ;
37694
37695 if (!args) SWIG_fail;
37696 swig_obj[0] = args;
37697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37698 if (!SWIG_IsOK(res1)) {
37699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37700 }
37701 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37702 {
37703 PyThreadState* __tstate = wxPyBeginAllowThreads();
37704 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37705 wxPyEndAllowThreads(__tstate);
37706 if (PyErr_Occurred()) SWIG_fail;
37707 }
37708 {
37709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37710 }
37711 return resultobj;
37712 fail:
37713 return NULL;
37714 }
37715
37716
37717 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37718 PyObject *resultobj = 0;
37719 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37720 wxString result;
37721 void *argp1 = 0 ;
37722 int res1 = 0 ;
37723 PyObject *swig_obj[1] ;
37724
37725 if (!args) SWIG_fail;
37726 swig_obj[0] = args;
37727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37728 if (!SWIG_IsOK(res1)) {
37729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37730 }
37731 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37732 {
37733 PyThreadState* __tstate = wxPyBeginAllowThreads();
37734 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37735 wxPyEndAllowThreads(__tstate);
37736 if (PyErr_Occurred()) SWIG_fail;
37737 }
37738 {
37739 #if wxUSE_UNICODE
37740 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37741 #else
37742 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37743 #endif
37744 }
37745 return resultobj;
37746 fail:
37747 return NULL;
37748 }
37749
37750
37751 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37752 PyObject *resultobj = 0;
37753 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37754 wxString *arg2 = 0 ;
37755 void *argp1 = 0 ;
37756 int res1 = 0 ;
37757 bool temp2 = false ;
37758 PyObject * obj0 = 0 ;
37759 PyObject * obj1 = 0 ;
37760 char * kwnames[] = {
37761 (char *) "self",(char *) "copyright", NULL
37762 };
37763
37764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37766 if (!SWIG_IsOK(res1)) {
37767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37768 }
37769 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37770 {
37771 arg2 = wxString_in_helper(obj1);
37772 if (arg2 == NULL) SWIG_fail;
37773 temp2 = true;
37774 }
37775 {
37776 PyThreadState* __tstate = wxPyBeginAllowThreads();
37777 (arg1)->SetCopyright((wxString const &)*arg2);
37778 wxPyEndAllowThreads(__tstate);
37779 if (PyErr_Occurred()) SWIG_fail;
37780 }
37781 resultobj = SWIG_Py_Void();
37782 {
37783 if (temp2)
37784 delete arg2;
37785 }
37786 return resultobj;
37787 fail:
37788 {
37789 if (temp2)
37790 delete arg2;
37791 }
37792 return NULL;
37793 }
37794
37795
37796 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37797 PyObject *resultobj = 0;
37798 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37799 bool result;
37800 void *argp1 = 0 ;
37801 int res1 = 0 ;
37802 PyObject *swig_obj[1] ;
37803
37804 if (!args) SWIG_fail;
37805 swig_obj[0] = args;
37806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37807 if (!SWIG_IsOK(res1)) {
37808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37809 }
37810 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37811 {
37812 PyThreadState* __tstate = wxPyBeginAllowThreads();
37813 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37814 wxPyEndAllowThreads(__tstate);
37815 if (PyErr_Occurred()) SWIG_fail;
37816 }
37817 {
37818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37819 }
37820 return resultobj;
37821 fail:
37822 return NULL;
37823 }
37824
37825
37826 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37827 PyObject *resultobj = 0;
37828 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37829 wxString result;
37830 void *argp1 = 0 ;
37831 int res1 = 0 ;
37832 PyObject *swig_obj[1] ;
37833
37834 if (!args) SWIG_fail;
37835 swig_obj[0] = args;
37836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37837 if (!SWIG_IsOK(res1)) {
37838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37839 }
37840 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37841 {
37842 PyThreadState* __tstate = wxPyBeginAllowThreads();
37843 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37844 wxPyEndAllowThreads(__tstate);
37845 if (PyErr_Occurred()) SWIG_fail;
37846 }
37847 {
37848 #if wxUSE_UNICODE
37849 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37850 #else
37851 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37852 #endif
37853 }
37854 return resultobj;
37855 fail:
37856 return NULL;
37857 }
37858
37859
37860 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37861 PyObject *resultobj = 0;
37862 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37863 wxString *arg2 = 0 ;
37864 void *argp1 = 0 ;
37865 int res1 = 0 ;
37866 bool temp2 = false ;
37867 PyObject * obj0 = 0 ;
37868 PyObject * obj1 = 0 ;
37869 char * kwnames[] = {
37870 (char *) "self",(char *) "licence", NULL
37871 };
37872
37873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37875 if (!SWIG_IsOK(res1)) {
37876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37877 }
37878 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37879 {
37880 arg2 = wxString_in_helper(obj1);
37881 if (arg2 == NULL) SWIG_fail;
37882 temp2 = true;
37883 }
37884 {
37885 PyThreadState* __tstate = wxPyBeginAllowThreads();
37886 (arg1)->SetLicence((wxString const &)*arg2);
37887 wxPyEndAllowThreads(__tstate);
37888 if (PyErr_Occurred()) SWIG_fail;
37889 }
37890 resultobj = SWIG_Py_Void();
37891 {
37892 if (temp2)
37893 delete arg2;
37894 }
37895 return resultobj;
37896 fail:
37897 {
37898 if (temp2)
37899 delete arg2;
37900 }
37901 return NULL;
37902 }
37903
37904
37905 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37906 PyObject *resultobj = 0;
37907 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37908 wxString *arg2 = 0 ;
37909 void *argp1 = 0 ;
37910 int res1 = 0 ;
37911 bool temp2 = false ;
37912 PyObject * obj0 = 0 ;
37913 PyObject * obj1 = 0 ;
37914 char * kwnames[] = {
37915 (char *) "self",(char *) "licence", NULL
37916 };
37917
37918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
37919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37920 if (!SWIG_IsOK(res1)) {
37921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37922 }
37923 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37924 {
37925 arg2 = wxString_in_helper(obj1);
37926 if (arg2 == NULL) SWIG_fail;
37927 temp2 = true;
37928 }
37929 {
37930 PyThreadState* __tstate = wxPyBeginAllowThreads();
37931 (arg1)->SetLicense((wxString const &)*arg2);
37932 wxPyEndAllowThreads(__tstate);
37933 if (PyErr_Occurred()) SWIG_fail;
37934 }
37935 resultobj = SWIG_Py_Void();
37936 {
37937 if (temp2)
37938 delete arg2;
37939 }
37940 return resultobj;
37941 fail:
37942 {
37943 if (temp2)
37944 delete arg2;
37945 }
37946 return NULL;
37947 }
37948
37949
37950 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37951 PyObject *resultobj = 0;
37952 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37953 bool result;
37954 void *argp1 = 0 ;
37955 int res1 = 0 ;
37956 PyObject *swig_obj[1] ;
37957
37958 if (!args) SWIG_fail;
37959 swig_obj[0] = args;
37960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37961 if (!SWIG_IsOK(res1)) {
37962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37963 }
37964 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37965 {
37966 PyThreadState* __tstate = wxPyBeginAllowThreads();
37967 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
37968 wxPyEndAllowThreads(__tstate);
37969 if (PyErr_Occurred()) SWIG_fail;
37970 }
37971 {
37972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37973 }
37974 return resultobj;
37975 fail:
37976 return NULL;
37977 }
37978
37979
37980 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37981 PyObject *resultobj = 0;
37982 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37983 wxString result;
37984 void *argp1 = 0 ;
37985 int res1 = 0 ;
37986 PyObject *swig_obj[1] ;
37987
37988 if (!args) SWIG_fail;
37989 swig_obj[0] = args;
37990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37991 if (!SWIG_IsOK(res1)) {
37992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37993 }
37994 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37995 {
37996 PyThreadState* __tstate = wxPyBeginAllowThreads();
37997 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
37998 wxPyEndAllowThreads(__tstate);
37999 if (PyErr_Occurred()) SWIG_fail;
38000 }
38001 {
38002 #if wxUSE_UNICODE
38003 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38004 #else
38005 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38006 #endif
38007 }
38008 return resultobj;
38009 fail:
38010 return NULL;
38011 }
38012
38013
38014 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38015 PyObject *resultobj = 0;
38016 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38017 wxIcon *arg2 = 0 ;
38018 void *argp1 = 0 ;
38019 int res1 = 0 ;
38020 void *argp2 = 0 ;
38021 int res2 = 0 ;
38022 PyObject * obj0 = 0 ;
38023 PyObject * obj1 = 0 ;
38024 char * kwnames[] = {
38025 (char *) "self",(char *) "icon", NULL
38026 };
38027
38028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38030 if (!SWIG_IsOK(res1)) {
38031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38032 }
38033 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38034 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38035 if (!SWIG_IsOK(res2)) {
38036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38037 }
38038 if (!argp2) {
38039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38040 }
38041 arg2 = reinterpret_cast< wxIcon * >(argp2);
38042 {
38043 PyThreadState* __tstate = wxPyBeginAllowThreads();
38044 (arg1)->SetIcon((wxIcon const &)*arg2);
38045 wxPyEndAllowThreads(__tstate);
38046 if (PyErr_Occurred()) SWIG_fail;
38047 }
38048 resultobj = SWIG_Py_Void();
38049 return resultobj;
38050 fail:
38051 return NULL;
38052 }
38053
38054
38055 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38056 PyObject *resultobj = 0;
38057 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38058 bool result;
38059 void *argp1 = 0 ;
38060 int res1 = 0 ;
38061 PyObject *swig_obj[1] ;
38062
38063 if (!args) SWIG_fail;
38064 swig_obj[0] = args;
38065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38066 if (!SWIG_IsOK(res1)) {
38067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38068 }
38069 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38070 {
38071 PyThreadState* __tstate = wxPyBeginAllowThreads();
38072 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38073 wxPyEndAllowThreads(__tstate);
38074 if (PyErr_Occurred()) SWIG_fail;
38075 }
38076 {
38077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38078 }
38079 return resultobj;
38080 fail:
38081 return NULL;
38082 }
38083
38084
38085 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38086 PyObject *resultobj = 0;
38087 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38088 wxIcon result;
38089 void *argp1 = 0 ;
38090 int res1 = 0 ;
38091 PyObject *swig_obj[1] ;
38092
38093 if (!args) SWIG_fail;
38094 swig_obj[0] = args;
38095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38096 if (!SWIG_IsOK(res1)) {
38097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38098 }
38099 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38100 {
38101 PyThreadState* __tstate = wxPyBeginAllowThreads();
38102 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38103 wxPyEndAllowThreads(__tstate);
38104 if (PyErr_Occurred()) SWIG_fail;
38105 }
38106 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38107 return resultobj;
38108 fail:
38109 return NULL;
38110 }
38111
38112
38113 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38114 PyObject *resultobj = 0;
38115 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38116 wxString *arg2 = 0 ;
38117 wxString const &arg3_defvalue = wxEmptyString ;
38118 wxString *arg3 = (wxString *) &arg3_defvalue ;
38119 void *argp1 = 0 ;
38120 int res1 = 0 ;
38121 bool temp2 = false ;
38122 bool temp3 = false ;
38123 PyObject * obj0 = 0 ;
38124 PyObject * obj1 = 0 ;
38125 PyObject * obj2 = 0 ;
38126 char * kwnames[] = {
38127 (char *) "self",(char *) "url",(char *) "desc", NULL
38128 };
38129
38130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38132 if (!SWIG_IsOK(res1)) {
38133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38134 }
38135 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38136 {
38137 arg2 = wxString_in_helper(obj1);
38138 if (arg2 == NULL) SWIG_fail;
38139 temp2 = true;
38140 }
38141 if (obj2) {
38142 {
38143 arg3 = wxString_in_helper(obj2);
38144 if (arg3 == NULL) SWIG_fail;
38145 temp3 = true;
38146 }
38147 }
38148 {
38149 PyThreadState* __tstate = wxPyBeginAllowThreads();
38150 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38151 wxPyEndAllowThreads(__tstate);
38152 if (PyErr_Occurred()) SWIG_fail;
38153 }
38154 resultobj = SWIG_Py_Void();
38155 {
38156 if (temp2)
38157 delete arg2;
38158 }
38159 {
38160 if (temp3)
38161 delete arg3;
38162 }
38163 return resultobj;
38164 fail:
38165 {
38166 if (temp2)
38167 delete arg2;
38168 }
38169 {
38170 if (temp3)
38171 delete arg3;
38172 }
38173 return NULL;
38174 }
38175
38176
38177 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38178 PyObject *resultobj = 0;
38179 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38180 wxString result;
38181 void *argp1 = 0 ;
38182 int res1 = 0 ;
38183 PyObject *swig_obj[1] ;
38184
38185 if (!args) SWIG_fail;
38186 swig_obj[0] = args;
38187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38188 if (!SWIG_IsOK(res1)) {
38189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38190 }
38191 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38192 {
38193 PyThreadState* __tstate = wxPyBeginAllowThreads();
38194 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38195 wxPyEndAllowThreads(__tstate);
38196 if (PyErr_Occurred()) SWIG_fail;
38197 }
38198 {
38199 #if wxUSE_UNICODE
38200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38201 #else
38202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38203 #endif
38204 }
38205 return resultobj;
38206 fail:
38207 return NULL;
38208 }
38209
38210
38211 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38212 PyObject *resultobj = 0;
38213 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38214 wxString 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__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38224 }
38225 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38226 {
38227 PyThreadState* __tstate = wxPyBeginAllowThreads();
38228 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38229 wxPyEndAllowThreads(__tstate);
38230 if (PyErr_Occurred()) SWIG_fail;
38231 }
38232 {
38233 #if wxUSE_UNICODE
38234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38235 #else
38236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38237 #endif
38238 }
38239 return resultobj;
38240 fail:
38241 return NULL;
38242 }
38243
38244
38245 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38246 PyObject *resultobj = 0;
38247 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38248 bool result;
38249 void *argp1 = 0 ;
38250 int res1 = 0 ;
38251 PyObject *swig_obj[1] ;
38252
38253 if (!args) SWIG_fail;
38254 swig_obj[0] = args;
38255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38256 if (!SWIG_IsOK(res1)) {
38257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38258 }
38259 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38260 {
38261 PyThreadState* __tstate = wxPyBeginAllowThreads();
38262 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38263 wxPyEndAllowThreads(__tstate);
38264 if (PyErr_Occurred()) SWIG_fail;
38265 }
38266 {
38267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38268 }
38269 return resultobj;
38270 fail:
38271 return NULL;
38272 }
38273
38274
38275 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38276 PyObject *resultobj = 0;
38277 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38278 wxArrayString *arg2 = 0 ;
38279 void *argp1 = 0 ;
38280 int res1 = 0 ;
38281 bool temp2 = false ;
38282 PyObject * obj0 = 0 ;
38283 PyObject * obj1 = 0 ;
38284 char * kwnames[] = {
38285 (char *) "self",(char *) "developers", NULL
38286 };
38287
38288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38290 if (!SWIG_IsOK(res1)) {
38291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38292 }
38293 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38294 {
38295 if (! PySequence_Check(obj1)) {
38296 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38297 SWIG_fail;
38298 }
38299 arg2 = new wxArrayString;
38300 temp2 = true;
38301 int i, len=PySequence_Length(obj1);
38302 for (i=0; i<len; i++) {
38303 PyObject* item = PySequence_GetItem(obj1, i);
38304 wxString* s = wxString_in_helper(item);
38305 if (PyErr_Occurred()) SWIG_fail;
38306 arg2->Add(*s);
38307 delete s;
38308 Py_DECREF(item);
38309 }
38310 }
38311 {
38312 PyThreadState* __tstate = wxPyBeginAllowThreads();
38313 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38314 wxPyEndAllowThreads(__tstate);
38315 if (PyErr_Occurred()) SWIG_fail;
38316 }
38317 resultobj = SWIG_Py_Void();
38318 {
38319 if (temp2) delete arg2;
38320 }
38321 return resultobj;
38322 fail:
38323 {
38324 if (temp2) delete arg2;
38325 }
38326 return NULL;
38327 }
38328
38329
38330 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38331 PyObject *resultobj = 0;
38332 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38333 wxString *arg2 = 0 ;
38334 void *argp1 = 0 ;
38335 int res1 = 0 ;
38336 bool temp2 = false ;
38337 PyObject * obj0 = 0 ;
38338 PyObject * obj1 = 0 ;
38339 char * kwnames[] = {
38340 (char *) "self",(char *) "developer", NULL
38341 };
38342
38343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38345 if (!SWIG_IsOK(res1)) {
38346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38347 }
38348 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38349 {
38350 arg2 = wxString_in_helper(obj1);
38351 if (arg2 == NULL) SWIG_fail;
38352 temp2 = true;
38353 }
38354 {
38355 PyThreadState* __tstate = wxPyBeginAllowThreads();
38356 (arg1)->AddDeveloper((wxString const &)*arg2);
38357 wxPyEndAllowThreads(__tstate);
38358 if (PyErr_Occurred()) SWIG_fail;
38359 }
38360 resultobj = SWIG_Py_Void();
38361 {
38362 if (temp2)
38363 delete arg2;
38364 }
38365 return resultobj;
38366 fail:
38367 {
38368 if (temp2)
38369 delete arg2;
38370 }
38371 return NULL;
38372 }
38373
38374
38375 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38376 PyObject *resultobj = 0;
38377 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38378 bool result;
38379 void *argp1 = 0 ;
38380 int res1 = 0 ;
38381 PyObject *swig_obj[1] ;
38382
38383 if (!args) SWIG_fail;
38384 swig_obj[0] = args;
38385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38386 if (!SWIG_IsOK(res1)) {
38387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38388 }
38389 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38390 {
38391 PyThreadState* __tstate = wxPyBeginAllowThreads();
38392 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38393 wxPyEndAllowThreads(__tstate);
38394 if (PyErr_Occurred()) SWIG_fail;
38395 }
38396 {
38397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38398 }
38399 return resultobj;
38400 fail:
38401 return NULL;
38402 }
38403
38404
38405 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38406 PyObject *resultobj = 0;
38407 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38408 wxArrayString *result = 0 ;
38409 void *argp1 = 0 ;
38410 int res1 = 0 ;
38411 PyObject *swig_obj[1] ;
38412
38413 if (!args) SWIG_fail;
38414 swig_obj[0] = args;
38415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38416 if (!SWIG_IsOK(res1)) {
38417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38418 }
38419 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38420 {
38421 PyThreadState* __tstate = wxPyBeginAllowThreads();
38422 {
38423 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38424 result = (wxArrayString *) &_result_ref;
38425 }
38426 wxPyEndAllowThreads(__tstate);
38427 if (PyErr_Occurred()) SWIG_fail;
38428 }
38429 {
38430 resultobj = wxArrayString2PyList_helper(*result);
38431 }
38432 return resultobj;
38433 fail:
38434 return NULL;
38435 }
38436
38437
38438 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38439 PyObject *resultobj = 0;
38440 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38441 wxArrayString *arg2 = 0 ;
38442 void *argp1 = 0 ;
38443 int res1 = 0 ;
38444 bool temp2 = false ;
38445 PyObject * obj0 = 0 ;
38446 PyObject * obj1 = 0 ;
38447 char * kwnames[] = {
38448 (char *) "self",(char *) "docwriters", NULL
38449 };
38450
38451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38453 if (!SWIG_IsOK(res1)) {
38454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38455 }
38456 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38457 {
38458 if (! PySequence_Check(obj1)) {
38459 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38460 SWIG_fail;
38461 }
38462 arg2 = new wxArrayString;
38463 temp2 = true;
38464 int i, len=PySequence_Length(obj1);
38465 for (i=0; i<len; i++) {
38466 PyObject* item = PySequence_GetItem(obj1, i);
38467 wxString* s = wxString_in_helper(item);
38468 if (PyErr_Occurred()) SWIG_fail;
38469 arg2->Add(*s);
38470 delete s;
38471 Py_DECREF(item);
38472 }
38473 }
38474 {
38475 PyThreadState* __tstate = wxPyBeginAllowThreads();
38476 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38477 wxPyEndAllowThreads(__tstate);
38478 if (PyErr_Occurred()) SWIG_fail;
38479 }
38480 resultobj = SWIG_Py_Void();
38481 {
38482 if (temp2) delete arg2;
38483 }
38484 return resultobj;
38485 fail:
38486 {
38487 if (temp2) delete arg2;
38488 }
38489 return NULL;
38490 }
38491
38492
38493 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38494 PyObject *resultobj = 0;
38495 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38496 wxString *arg2 = 0 ;
38497 void *argp1 = 0 ;
38498 int res1 = 0 ;
38499 bool temp2 = false ;
38500 PyObject * obj0 = 0 ;
38501 PyObject * obj1 = 0 ;
38502 char * kwnames[] = {
38503 (char *) "self",(char *) "docwriter", NULL
38504 };
38505
38506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38508 if (!SWIG_IsOK(res1)) {
38509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38510 }
38511 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38512 {
38513 arg2 = wxString_in_helper(obj1);
38514 if (arg2 == NULL) SWIG_fail;
38515 temp2 = true;
38516 }
38517 {
38518 PyThreadState* __tstate = wxPyBeginAllowThreads();
38519 (arg1)->AddDocWriter((wxString const &)*arg2);
38520 wxPyEndAllowThreads(__tstate);
38521 if (PyErr_Occurred()) SWIG_fail;
38522 }
38523 resultobj = SWIG_Py_Void();
38524 {
38525 if (temp2)
38526 delete arg2;
38527 }
38528 return resultobj;
38529 fail:
38530 {
38531 if (temp2)
38532 delete arg2;
38533 }
38534 return NULL;
38535 }
38536
38537
38538 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38539 PyObject *resultobj = 0;
38540 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38541 bool result;
38542 void *argp1 = 0 ;
38543 int res1 = 0 ;
38544 PyObject *swig_obj[1] ;
38545
38546 if (!args) SWIG_fail;
38547 swig_obj[0] = args;
38548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38549 if (!SWIG_IsOK(res1)) {
38550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38551 }
38552 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38553 {
38554 PyThreadState* __tstate = wxPyBeginAllowThreads();
38555 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38556 wxPyEndAllowThreads(__tstate);
38557 if (PyErr_Occurred()) SWIG_fail;
38558 }
38559 {
38560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38561 }
38562 return resultobj;
38563 fail:
38564 return NULL;
38565 }
38566
38567
38568 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38569 PyObject *resultobj = 0;
38570 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38571 wxArrayString *result = 0 ;
38572 void *argp1 = 0 ;
38573 int res1 = 0 ;
38574 PyObject *swig_obj[1] ;
38575
38576 if (!args) SWIG_fail;
38577 swig_obj[0] = args;
38578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38579 if (!SWIG_IsOK(res1)) {
38580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38581 }
38582 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38583 {
38584 PyThreadState* __tstate = wxPyBeginAllowThreads();
38585 {
38586 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38587 result = (wxArrayString *) &_result_ref;
38588 }
38589 wxPyEndAllowThreads(__tstate);
38590 if (PyErr_Occurred()) SWIG_fail;
38591 }
38592 {
38593 resultobj = wxArrayString2PyList_helper(*result);
38594 }
38595 return resultobj;
38596 fail:
38597 return NULL;
38598 }
38599
38600
38601 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38602 PyObject *resultobj = 0;
38603 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38604 wxArrayString *arg2 = 0 ;
38605 void *argp1 = 0 ;
38606 int res1 = 0 ;
38607 bool temp2 = false ;
38608 PyObject * obj0 = 0 ;
38609 PyObject * obj1 = 0 ;
38610 char * kwnames[] = {
38611 (char *) "self",(char *) "artists", NULL
38612 };
38613
38614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38616 if (!SWIG_IsOK(res1)) {
38617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38618 }
38619 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38620 {
38621 if (! PySequence_Check(obj1)) {
38622 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38623 SWIG_fail;
38624 }
38625 arg2 = new wxArrayString;
38626 temp2 = true;
38627 int i, len=PySequence_Length(obj1);
38628 for (i=0; i<len; i++) {
38629 PyObject* item = PySequence_GetItem(obj1, i);
38630 wxString* s = wxString_in_helper(item);
38631 if (PyErr_Occurred()) SWIG_fail;
38632 arg2->Add(*s);
38633 delete s;
38634 Py_DECREF(item);
38635 }
38636 }
38637 {
38638 PyThreadState* __tstate = wxPyBeginAllowThreads();
38639 (arg1)->SetArtists((wxArrayString const &)*arg2);
38640 wxPyEndAllowThreads(__tstate);
38641 if (PyErr_Occurred()) SWIG_fail;
38642 }
38643 resultobj = SWIG_Py_Void();
38644 {
38645 if (temp2) delete arg2;
38646 }
38647 return resultobj;
38648 fail:
38649 {
38650 if (temp2) delete arg2;
38651 }
38652 return NULL;
38653 }
38654
38655
38656 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38657 PyObject *resultobj = 0;
38658 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38659 wxString *arg2 = 0 ;
38660 void *argp1 = 0 ;
38661 int res1 = 0 ;
38662 bool temp2 = false ;
38663 PyObject * obj0 = 0 ;
38664 PyObject * obj1 = 0 ;
38665 char * kwnames[] = {
38666 (char *) "self",(char *) "artist", NULL
38667 };
38668
38669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38671 if (!SWIG_IsOK(res1)) {
38672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38673 }
38674 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38675 {
38676 arg2 = wxString_in_helper(obj1);
38677 if (arg2 == NULL) SWIG_fail;
38678 temp2 = true;
38679 }
38680 {
38681 PyThreadState* __tstate = wxPyBeginAllowThreads();
38682 (arg1)->AddArtist((wxString const &)*arg2);
38683 wxPyEndAllowThreads(__tstate);
38684 if (PyErr_Occurred()) SWIG_fail;
38685 }
38686 resultobj = SWIG_Py_Void();
38687 {
38688 if (temp2)
38689 delete arg2;
38690 }
38691 return resultobj;
38692 fail:
38693 {
38694 if (temp2)
38695 delete arg2;
38696 }
38697 return NULL;
38698 }
38699
38700
38701 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38702 PyObject *resultobj = 0;
38703 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38704 bool result;
38705 void *argp1 = 0 ;
38706 int res1 = 0 ;
38707 PyObject *swig_obj[1] ;
38708
38709 if (!args) SWIG_fail;
38710 swig_obj[0] = args;
38711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38712 if (!SWIG_IsOK(res1)) {
38713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38714 }
38715 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38716 {
38717 PyThreadState* __tstate = wxPyBeginAllowThreads();
38718 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38719 wxPyEndAllowThreads(__tstate);
38720 if (PyErr_Occurred()) SWIG_fail;
38721 }
38722 {
38723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38724 }
38725 return resultobj;
38726 fail:
38727 return NULL;
38728 }
38729
38730
38731 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38732 PyObject *resultobj = 0;
38733 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38734 wxArrayString *result = 0 ;
38735 void *argp1 = 0 ;
38736 int res1 = 0 ;
38737 PyObject *swig_obj[1] ;
38738
38739 if (!args) SWIG_fail;
38740 swig_obj[0] = args;
38741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38742 if (!SWIG_IsOK(res1)) {
38743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38744 }
38745 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38746 {
38747 PyThreadState* __tstate = wxPyBeginAllowThreads();
38748 {
38749 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38750 result = (wxArrayString *) &_result_ref;
38751 }
38752 wxPyEndAllowThreads(__tstate);
38753 if (PyErr_Occurred()) SWIG_fail;
38754 }
38755 {
38756 resultobj = wxArrayString2PyList_helper(*result);
38757 }
38758 return resultobj;
38759 fail:
38760 return NULL;
38761 }
38762
38763
38764 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38765 PyObject *resultobj = 0;
38766 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38767 wxArrayString *arg2 = 0 ;
38768 void *argp1 = 0 ;
38769 int res1 = 0 ;
38770 bool temp2 = false ;
38771 PyObject * obj0 = 0 ;
38772 PyObject * obj1 = 0 ;
38773 char * kwnames[] = {
38774 (char *) "self",(char *) "translators", NULL
38775 };
38776
38777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38779 if (!SWIG_IsOK(res1)) {
38780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38781 }
38782 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38783 {
38784 if (! PySequence_Check(obj1)) {
38785 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38786 SWIG_fail;
38787 }
38788 arg2 = new wxArrayString;
38789 temp2 = true;
38790 int i, len=PySequence_Length(obj1);
38791 for (i=0; i<len; i++) {
38792 PyObject* item = PySequence_GetItem(obj1, i);
38793 wxString* s = wxString_in_helper(item);
38794 if (PyErr_Occurred()) SWIG_fail;
38795 arg2->Add(*s);
38796 delete s;
38797 Py_DECREF(item);
38798 }
38799 }
38800 {
38801 PyThreadState* __tstate = wxPyBeginAllowThreads();
38802 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38803 wxPyEndAllowThreads(__tstate);
38804 if (PyErr_Occurred()) SWIG_fail;
38805 }
38806 resultobj = SWIG_Py_Void();
38807 {
38808 if (temp2) delete arg2;
38809 }
38810 return resultobj;
38811 fail:
38812 {
38813 if (temp2) delete arg2;
38814 }
38815 return NULL;
38816 }
38817
38818
38819 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38820 PyObject *resultobj = 0;
38821 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38822 wxString *arg2 = 0 ;
38823 void *argp1 = 0 ;
38824 int res1 = 0 ;
38825 bool temp2 = false ;
38826 PyObject * obj0 = 0 ;
38827 PyObject * obj1 = 0 ;
38828 char * kwnames[] = {
38829 (char *) "self",(char *) "translator", NULL
38830 };
38831
38832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38834 if (!SWIG_IsOK(res1)) {
38835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38836 }
38837 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38838 {
38839 arg2 = wxString_in_helper(obj1);
38840 if (arg2 == NULL) SWIG_fail;
38841 temp2 = true;
38842 }
38843 {
38844 PyThreadState* __tstate = wxPyBeginAllowThreads();
38845 (arg1)->AddTranslator((wxString const &)*arg2);
38846 wxPyEndAllowThreads(__tstate);
38847 if (PyErr_Occurred()) SWIG_fail;
38848 }
38849 resultobj = SWIG_Py_Void();
38850 {
38851 if (temp2)
38852 delete arg2;
38853 }
38854 return resultobj;
38855 fail:
38856 {
38857 if (temp2)
38858 delete arg2;
38859 }
38860 return NULL;
38861 }
38862
38863
38864 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38865 PyObject *resultobj = 0;
38866 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38867 bool result;
38868 void *argp1 = 0 ;
38869 int res1 = 0 ;
38870 PyObject *swig_obj[1] ;
38871
38872 if (!args) SWIG_fail;
38873 swig_obj[0] = args;
38874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38875 if (!SWIG_IsOK(res1)) {
38876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38877 }
38878 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38879 {
38880 PyThreadState* __tstate = wxPyBeginAllowThreads();
38881 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
38882 wxPyEndAllowThreads(__tstate);
38883 if (PyErr_Occurred()) SWIG_fail;
38884 }
38885 {
38886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38887 }
38888 return resultobj;
38889 fail:
38890 return NULL;
38891 }
38892
38893
38894 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38895 PyObject *resultobj = 0;
38896 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38897 wxArrayString *result = 0 ;
38898 void *argp1 = 0 ;
38899 int res1 = 0 ;
38900 PyObject *swig_obj[1] ;
38901
38902 if (!args) SWIG_fail;
38903 swig_obj[0] = args;
38904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38905 if (!SWIG_IsOK(res1)) {
38906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38907 }
38908 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38909 {
38910 PyThreadState* __tstate = wxPyBeginAllowThreads();
38911 {
38912 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
38913 result = (wxArrayString *) &_result_ref;
38914 }
38915 wxPyEndAllowThreads(__tstate);
38916 if (PyErr_Occurred()) SWIG_fail;
38917 }
38918 {
38919 resultobj = wxArrayString2PyList_helper(*result);
38920 }
38921 return resultobj;
38922 fail:
38923 return NULL;
38924 }
38925
38926
38927 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38928 PyObject *resultobj = 0;
38929 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38930 bool result;
38931 void *argp1 = 0 ;
38932 int res1 = 0 ;
38933 PyObject *swig_obj[1] ;
38934
38935 if (!args) SWIG_fail;
38936 swig_obj[0] = args;
38937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38938 if (!SWIG_IsOK(res1)) {
38939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38940 }
38941 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38942 {
38943 PyThreadState* __tstate = wxPyBeginAllowThreads();
38944 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
38945 wxPyEndAllowThreads(__tstate);
38946 if (PyErr_Occurred()) SWIG_fail;
38947 }
38948 {
38949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38950 }
38951 return resultobj;
38952 fail:
38953 return NULL;
38954 }
38955
38956
38957 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38958 PyObject *resultobj = 0;
38959 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38960 wxString result;
38961 void *argp1 = 0 ;
38962 int res1 = 0 ;
38963 PyObject *swig_obj[1] ;
38964
38965 if (!args) SWIG_fail;
38966 swig_obj[0] = args;
38967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38968 if (!SWIG_IsOK(res1)) {
38969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38970 }
38971 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38972 {
38973 PyThreadState* __tstate = wxPyBeginAllowThreads();
38974 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
38975 wxPyEndAllowThreads(__tstate);
38976 if (PyErr_Occurred()) SWIG_fail;
38977 }
38978 {
38979 #if wxUSE_UNICODE
38980 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38981 #else
38982 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38983 #endif
38984 }
38985 return resultobj;
38986 fail:
38987 return NULL;
38988 }
38989
38990
38991 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38992 PyObject *obj;
38993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38994 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
38995 return SWIG_Py_Void();
38996 }
38997
38998 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38999 return SWIG_Python_InitShadowInstance(args);
39000 }
39001
39002 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39003 PyObject *resultobj = 0;
39004 wxAboutDialogInfo *arg1 = 0 ;
39005 void *argp1 = 0 ;
39006 int res1 = 0 ;
39007 PyObject * obj0 = 0 ;
39008 char * kwnames[] = {
39009 (char *) "info", NULL
39010 };
39011
39012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39013 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39014 if (!SWIG_IsOK(res1)) {
39015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39016 }
39017 if (!argp1) {
39018 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39019 }
39020 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39021 {
39022 PyThreadState* __tstate = wxPyBeginAllowThreads();
39023 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39024 wxPyEndAllowThreads(__tstate);
39025 if (PyErr_Occurred()) SWIG_fail;
39026 }
39027 resultobj = SWIG_Py_Void();
39028 return resultobj;
39029 fail:
39030 return NULL;
39031 }
39032
39033
39034 static PyMethodDef SwigMethods[] = {
39035 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39036 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39037 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39038 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39039 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39040 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39041 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39042 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39043 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39044 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39045 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39046 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39047 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39048 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39049 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39050 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39051 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39052 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39053 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39054 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39055 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39056 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39057 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39058 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39059 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39060 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39061 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39062 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39063 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39064 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39065 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39066 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39067 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39068 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39069 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39070 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39071 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39072 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39073 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39074 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39075 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39076 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39077 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39078 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39079 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39080 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39081 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39082 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39083 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39084 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39085 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39086 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39087 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39088 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39089 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39090 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39091 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39092 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39093 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39094 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39095 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39096 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39097 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39098 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39099 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39100 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39101 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39102 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39103 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39104 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39105 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39106 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39107 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39108 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39109 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39110 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39111 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39112 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39113 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39114 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39115 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39116 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39117 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39118 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39119 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39120 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39121 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39122 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39123 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39124 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39125 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39126 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39127 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39128 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39129 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39130 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39131 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39132 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39133 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39134 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39135 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39136 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39137 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39138 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39139 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39140 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39141 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39142 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39143 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39144 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39145 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39146 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39147 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39148 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39149 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39150 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39151 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39152 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39153 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39154 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39155 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39156 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39157 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39158 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39159 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39160 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39161 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39162 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39163 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39164 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39165 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39166 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39167 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39168 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39169 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39170 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39171 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39172 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39173 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39174 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39175 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39176 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39177 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39178 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39179 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39180 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39181 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39182 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39183 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39184 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39185 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39186 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39187 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39188 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39189 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39190 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39191 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39192 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39193 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39194 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39195 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39196 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39197 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39198 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39199 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39200 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39201 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39202 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39203 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39204 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39205 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39206 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39207 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39208 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39209 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39210 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39211 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39212 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39213 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39214 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39215 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39216 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39217 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39218 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39219 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39220 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39221 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39222 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39223 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39224 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39225 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39226 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39227 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39228 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39229 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39230 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39231 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39232 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39233 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39234 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39235 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39236 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39237 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39238 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39239 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39240 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39241 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39242 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39243 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39244 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39245 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39246 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39248 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39249 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39250 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39251 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39252 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39253 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39255 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39256 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39257 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39258 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39259 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39260 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39261 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39263 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39264 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39265 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39266 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39267 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39268 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39269 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39270 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39271 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39272 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39273 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39274 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39275 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39276 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39277 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39278 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39279 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39280 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39281 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39282 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39283 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39284 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39285 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39287 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39288 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39289 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39291 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39292 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39293 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39294 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39295 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39296 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39297 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39298 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39299 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39300 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39301 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39302 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39303 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39304 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39305 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39306 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39307 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39308 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39309 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39310 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39311 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39312 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39313 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39314 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39315 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39316 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39317 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39318 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39319 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39320 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39321 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39323 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39324 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39325 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39326 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39327 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39328 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39329 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39330 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39331 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39332 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39333 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39334 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39335 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39336 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39337 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39338 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39339 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39340 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39341 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39342 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39343 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39344 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39345 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39346 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39347 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39348 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39349 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39350 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39351 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39352 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39353 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39354 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39355 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39356 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39357 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39358 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39359 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39360 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39361 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39362 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39363 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39365 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39366 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39367 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39368 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39369 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39370 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39371 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39372 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39373 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39374 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39375 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39376 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39377 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39378 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39379 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39380 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39381 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39383 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39384 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39385 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39386 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39387 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39388 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39389 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39390 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39391 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39392 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39393 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39394 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39395 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39396 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39397 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39398 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39399 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39400 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39401 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39402 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39403 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39405 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39406 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39407 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39408 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39409 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39410 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39411 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39412 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39413 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39414 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39415 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39416 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39417 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39418 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39419 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39420 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39421 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39422 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39423 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39424 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39425 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39426 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39427 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39428 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39429 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39430 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39431 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39432 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39433 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39434 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39435 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39436 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39437 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39438 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39439 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39440 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39441 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39442 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39443 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39444 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39445 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39446 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39447 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39448 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39449 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39450 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39451 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39452 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39454 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39455 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39456 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39457 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39458 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39459 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39460 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39461 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39462 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39463 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39465 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39466 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39467 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39468 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39469 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39470 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39471 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39472 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39473 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39474 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39475 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39476 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39477 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39478 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39479 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39480 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39481 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39482 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39483 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39484 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39485 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39486 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39487 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39488 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39489 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39490 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39491 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39492 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39493 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39494 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39495 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39496 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39497 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39498 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39499 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39500 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39501 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39502 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39503 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39504 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39505 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39506 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39507 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39509 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39510 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39511 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39512 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39513 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39514 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39515 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39516 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39517 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39518 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39519 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39520 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39521 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39522 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39523 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39524 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39526 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39527 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39528 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39529 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39530 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39531 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39532 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39533 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39534 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39535 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39536 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39537 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39538 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39539 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39540 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39541 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39542 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39543 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39544 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39545 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39546 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39547 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39548 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39549 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39550 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39551 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39552 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39553 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39554 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39555 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39556 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39558 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39559 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39560 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39561 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39562 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39563 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39564 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39565 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39566 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39567 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39568 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39571 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39572 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39573 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39575 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39576 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39577 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39578 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39579 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39580 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39581 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39582 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39583 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39584 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39585 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39586 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39587 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39588 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39589 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39590 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39591 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39592 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39593 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39594 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39595 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39596 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39597 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39598 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39599 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39600 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39601 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39602 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39603 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39604 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39605 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39606 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39607 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39610 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39613 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39614 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39619 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39621 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39623 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39624 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39625 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39626 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39627 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39628 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39630 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39632 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39633 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39634 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39636 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39637 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39638 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39639 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39641 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39642 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39643 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39644 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39645 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39646 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39647 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39648 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39652 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39659 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39660 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39667 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39676 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39680 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39681 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39682 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39686 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39687 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39688 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39689 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39702 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39703 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39704 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39705 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39706 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39707 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39709 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39711 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39713 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39715 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39717 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39719 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39721 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39725 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39726 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39730 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39741 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39742 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39743 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39747 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39748 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39749 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39750 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39751 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39752 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39754 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39755 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39757 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39759 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39761 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39763 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39765 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39766 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39769 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39770 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39771 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39772 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39773 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39774 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39777 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39781 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39789 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39790 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39791 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39792 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39793 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39794 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39797 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39798 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39799 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39801 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39802 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39803 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39804 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39805 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39806 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39809 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39810 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39814 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39816 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39817 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39818 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39819 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39821 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39822 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39825 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39826 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39827 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39829 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39830 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39831 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39833 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39834 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39836 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39837 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39840 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39841 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39843 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39845 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39846 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39849 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39850 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39851 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39852 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39854 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39855 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39856 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39858 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39859 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39860 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39861 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39863 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39864 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39865 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39866 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39867 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
39869 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39870 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39871 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39875 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39877 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
39881 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
39882 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
39885 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
39886 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39888 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39889 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
39890 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
39892 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
39893 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
39894 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
39895 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
39896 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
39897 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
39902 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
39905 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
39906 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
39907 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39908 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
39912 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39913 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39914 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
39915 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
39916 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
39917 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
39918 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
39919 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
39920 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
39921 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
39926 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
39927 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
39928 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
39929 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
39930 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
39931 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
39933 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
39934 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
39935 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
39936 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
39938 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
39940 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
39941 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
39942 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
39943 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39945 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
39946 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
39947 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
39948 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
39949 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
39950 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
39951 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
39952 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
39953 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
39954 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
39955 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
39956 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
39957 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
39958 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39959 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39960 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
39961 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
39962 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
39963 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
39964 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
39965 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
39966 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
39967 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
39969 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
39970 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
39971 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
39972 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
39973 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
39974 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
39975 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
39976 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
39977 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
39978 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
39979 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
39980 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
39981 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
39982 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
39983 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
39984 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
39985 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
39987 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
39988 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
39989 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
39990 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
39991 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
39992 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
39993 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
39994 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
39995 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
39996 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
39998 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
39999 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40001 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40002 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40003 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40004 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40005 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40006 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40007 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40008 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40009 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40010 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40011 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40012 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40013 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40014 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40015 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40016 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40017 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40018 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40019 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40020 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40021 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40023 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40024 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40025 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40027 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40028 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40029 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40030 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40031 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40032 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40033 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40034 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40035 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40036 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40037 { NULL, NULL, 0, NULL }
40038 };
40039
40040
40041 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40042
40043 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40044 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40045 }
40046 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40047 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40048 }
40049 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40050 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40051 }
40052 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40053 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40054 }
40055 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40056 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40057 }
40058 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40059 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40060 }
40061 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40062 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40063 }
40064 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40065 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40066 }
40067 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40068 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40069 }
40070 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40071 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40072 }
40073 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40074 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40075 }
40076 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40077 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40078 }
40079 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40080 return (void *)((wxEvent *) ((wxPyEvent *) x));
40081 }
40082 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40083 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40084 }
40085 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40086 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40087 }
40088 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40089 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40090 }
40091 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40092 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40093 }
40094 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40095 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40096 }
40097 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40098 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40099 }
40100 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40101 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40102 }
40103 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40104 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40105 }
40106 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40107 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40108 }
40109 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40110 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40111 }
40112 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40113 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40114 }
40115 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40116 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40117 }
40118 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40119 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40120 }
40121 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40122 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40123 }
40124 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40125 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40126 }
40127 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40128 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40129 }
40130 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40131 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40132 }
40133 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40134 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40135 }
40136 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40137 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40138 }
40139 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40140 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40141 }
40142 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40143 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40144 }
40145 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40146 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40147 }
40148 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40149 return (void *)((wxEvent *) ((wxShowEvent *) x));
40150 }
40151 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40152 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40153 }
40154 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40155 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40156 }
40157 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40158 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40159 }
40160 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40161 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40162 }
40163 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40164 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40165 }
40166 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40167 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40168 }
40169 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40170 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40171 }
40172 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40173 return (void *)((wxConfigBase *) ((wxConfig *) x));
40174 }
40175 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40176 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40177 }
40178 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40179 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40180 }
40181 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40182 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40183 }
40184 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40185 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40186 }
40187 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40188 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40189 }
40190 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40191 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40192 }
40193 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40194 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40195 }
40196 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40197 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40198 }
40199 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40200 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40201 }
40202 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40203 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40204 }
40205 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40206 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40207 }
40208 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40209 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40210 }
40211 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40212 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40213 }
40214 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40215 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40216 }
40217 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40218 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40219 }
40220 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40221 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40222 }
40223 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40224 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40225 }
40226 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40227 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40228 }
40229 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40230 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40231 }
40232 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40233 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40234 }
40235 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40236 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40237 }
40238 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40239 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40240 }
40241 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40242 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40243 }
40244 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40245 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40246 }
40247 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40248 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40249 }
40250 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40251 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40252 }
40253 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40254 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40255 }
40256 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40257 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40258 }
40259 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40260 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40261 }
40262 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40263 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40264 }
40265 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40266 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40267 }
40268 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40269 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40270 }
40271 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40272 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40273 }
40274 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40275 return (void *)((wxObject *) ((wxSizerItem *) x));
40276 }
40277 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40278 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40279 }
40280 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40281 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40282 }
40283 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40284 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40285 }
40286 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40287 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40288 }
40289 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40290 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40291 }
40292 static void *_p_wxSizerTo_p_wxObject(void *x) {
40293 return (void *)((wxObject *) ((wxSizer *) x));
40294 }
40295 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40296 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40297 }
40298 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40299 return (void *)((wxObject *) ((wxFileHistory *) x));
40300 }
40301 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40302 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40303 }
40304 static void *_p_wxEventTo_p_wxObject(void *x) {
40305 return (void *)((wxObject *) ((wxEvent *) x));
40306 }
40307 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40308 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40309 }
40310 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40311 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40312 }
40313 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40314 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40315 }
40316 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40317 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40318 }
40319 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40320 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40321 }
40322 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40323 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40324 }
40325 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40326 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40327 }
40328 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40329 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40330 }
40331 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40332 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40333 }
40334 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40335 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40336 }
40337 static void *_p_wxControlTo_p_wxObject(void *x) {
40338 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40339 }
40340 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40341 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40342 }
40343 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40344 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40345 }
40346 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40347 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40348 }
40349 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40350 return (void *)((wxObject *) ((wxFSFile *) x));
40351 }
40352 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40353 return (void *)((wxObject *) ((wxClipboard *) x));
40354 }
40355 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40356 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40357 }
40358 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40359 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40360 }
40361 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40362 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40363 }
40364 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40365 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40366 }
40367 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40368 return (void *)((wxObject *) ((wxToolTip *) x));
40369 }
40370 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40371 return (void *)((wxObject *) ((wxMenuItem *) x));
40372 }
40373 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40374 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40375 }
40376 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40377 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40378 }
40379 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40380 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40381 }
40382 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40383 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40384 }
40385 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40386 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40387 }
40388 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40389 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40390 }
40391 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40392 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40393 }
40394 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40395 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40396 }
40397 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40398 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40399 }
40400 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40401 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40402 }
40403 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40404 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40405 }
40406 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40407 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40408 }
40409 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40410 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40411 }
40412 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40413 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40414 }
40415 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40416 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40417 }
40418 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40419 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40420 }
40421 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40422 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40423 }
40424 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40425 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40426 }
40427 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40428 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40429 }
40430 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40431 return (void *)((wxObject *) ((wxImageHandler *) x));
40432 }
40433 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40434 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40435 }
40436 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40437 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40438 }
40439 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40440 return (void *)((wxObject *) ((wxEvtHandler *) x));
40441 }
40442 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40443 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40444 }
40445 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40446 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40447 }
40448 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40449 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40450 }
40451 static void *_p_wxImageTo_p_wxObject(void *x) {
40452 return (void *)((wxObject *) ((wxImage *) x));
40453 }
40454 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40455 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40456 }
40457 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40458 return (void *)((wxObject *) ((wxSystemOptions *) x));
40459 }
40460 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40461 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40462 }
40463 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40464 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40465 }
40466 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40467 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40468 }
40469 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40470 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40471 }
40472 static void *_p_wxWindowTo_p_wxObject(void *x) {
40473 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40474 }
40475 static void *_p_wxMenuTo_p_wxObject(void *x) {
40476 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40477 }
40478 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40479 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40480 }
40481 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40482 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40483 }
40484 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40485 return (void *)((wxObject *) ((wxFileSystem *) x));
40486 }
40487 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40488 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40489 }
40490 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40491 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40492 }
40493 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40494 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40495 }
40496 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40497 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40498 }
40499 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40500 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40501 }
40502 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40503 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40504 }
40505 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40506 return (void *)((wxObject *) ((wxBusyInfo *) x));
40507 }
40508 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40509 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40510 }
40511 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40512 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40513 }
40514 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40515 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40516 }
40517 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40518 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40519 }
40520 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40521 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40522 }
40523 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40524 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40525 }
40526 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40527 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40528 }
40529 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40530 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40531 }
40532 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40533 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40534 }
40535 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40536 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40537 }
40538 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40539 return (void *)((wxLog *) ((wxLogBuffer *) x));
40540 }
40541 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40542 return (void *)((wxLog *) ((wxLogStderr *) x));
40543 }
40544 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40545 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40546 }
40547 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40548 return (void *)((wxLog *) ((wxLogWindow *) x));
40549 }
40550 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40551 return (void *)((wxLog *) ((wxLogChain *) x));
40552 }
40553 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40554 return (void *)((wxLog *) ((wxLogGui *) x));
40555 }
40556 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40557 return (void *)((wxLog *) ((wxPyLog *) x));
40558 }
40559 static void *_p_wxControlTo_p_wxWindow(void *x) {
40560 return (void *)((wxWindow *) ((wxControl *) x));
40561 }
40562 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40563 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40564 }
40565 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40566 return (void *)((wxWindow *) ((wxMenuBar *) x));
40567 }
40568 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40569 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40570 }
40571 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40572 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40573 }
40574 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40575 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};
40576 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40577 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40578 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40579 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40580 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40581 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40582 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40583 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40584 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40585 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40586 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40587 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40588 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40589 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40590 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40591 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40592 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40593 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40594 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40595 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40596 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40597 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40598 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40599 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40600 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40601 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40602 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40603 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40604 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40605 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40606 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40607 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40608 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40609 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40610 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40611 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40612 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40613 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40614 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40615 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40616 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40617 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40618 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40619 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40620 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40621 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40622 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40623 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40624 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40625 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40626 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40627 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40628 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40629 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40630 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40631 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40632 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40633 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40634 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40635 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40636 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40637 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40638 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40639 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40640 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40641 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40642 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40643 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40644 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40645 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40646 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40647 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40648 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40649 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40650 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40651 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40652 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40653 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40654 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40655 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40656 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40657 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40658 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40659 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40660 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40661 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40662 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40663 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40664 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40665 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40666 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40667 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40668 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40669 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40670 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40671 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40672 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40673 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
40674 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40675 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40676 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40677 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40678 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40679 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40680 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40681 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40682 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40683 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40684 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40685 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40686 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40687 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40688 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40689 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40690 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40691 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40692 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40693 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40694 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40695 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40696 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40697 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40698 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40699 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40700 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40701 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40702 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40703 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40704 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40705 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40706 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40707 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40708 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40709 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40710 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40711 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40712 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40713 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40714 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40715 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40716 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40717 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40718 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40719 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40720 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40721 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40722 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40723 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40724 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40725 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40726 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40727 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40728 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40729 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40730 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40731 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40732 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40733 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40734 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40735 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40736 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40737 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40738 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40739 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40740 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40741 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40742 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40743 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40744 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40745 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40746 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40747 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40748
40749 static swig_type_info *swig_type_initial[] = {
40750 &_swigt__p_char,
40751 &_swigt__p_form_ops_t,
40752 &_swigt__p_int,
40753 &_swigt__p_unsigned_char,
40754 &_swigt__p_unsigned_int,
40755 &_swigt__p_unsigned_long,
40756 &_swigt__p_void,
40757 &_swigt__p_wxANIHandler,
40758 &_swigt__p_wxAboutDialogInfo,
40759 &_swigt__p_wxAcceleratorTable,
40760 &_swigt__p_wxActivateEvent,
40761 &_swigt__p_wxArrayString,
40762 &_swigt__p_wxBMPHandler,
40763 &_swigt__p_wxBitmap,
40764 &_swigt__p_wxBitmapDataObject,
40765 &_swigt__p_wxBoxSizer,
40766 &_swigt__p_wxBusyCursor,
40767 &_swigt__p_wxBusyInfo,
40768 &_swigt__p_wxCURHandler,
40769 &_swigt__p_wxCaret,
40770 &_swigt__p_wxChar,
40771 &_swigt__p_wxChildFocusEvent,
40772 &_swigt__p_wxClipboard,
40773 &_swigt__p_wxClipboardLocker,
40774 &_swigt__p_wxClipboardTextEvent,
40775 &_swigt__p_wxCloseEvent,
40776 &_swigt__p_wxColour,
40777 &_swigt__p_wxCommandEvent,
40778 &_swigt__p_wxConfig,
40779 &_swigt__p_wxConfigBase,
40780 &_swigt__p_wxConfigPathChanger,
40781 &_swigt__p_wxContextMenuEvent,
40782 &_swigt__p_wxControl,
40783 &_swigt__p_wxControlWithItems,
40784 &_swigt__p_wxCursor,
40785 &_swigt__p_wxCustomDataObject,
40786 &_swigt__p_wxDC,
40787 &_swigt__p_wxDataFormat,
40788 &_swigt__p_wxDataObject,
40789 &_swigt__p_wxDataObjectComposite,
40790 &_swigt__p_wxDataObjectSimple,
40791 &_swigt__p_wxDateEvent,
40792 &_swigt__p_wxDateSpan,
40793 &_swigt__p_wxDateTime,
40794 &_swigt__p_wxDateTime__TimeZone,
40795 &_swigt__p_wxDisplay,
40796 &_swigt__p_wxDisplayChangedEvent,
40797 &_swigt__p_wxDropFilesEvent,
40798 &_swigt__p_wxDuplexMode,
40799 &_swigt__p_wxEraseEvent,
40800 &_swigt__p_wxEvent,
40801 &_swigt__p_wxEvtHandler,
40802 &_swigt__p_wxFSFile,
40803 &_swigt__p_wxFileConfig,
40804 &_swigt__p_wxFileDataObject,
40805 &_swigt__p_wxFileHistory,
40806 &_swigt__p_wxFileSystem,
40807 &_swigt__p_wxFileType,
40808 &_swigt__p_wxFileTypeInfo,
40809 &_swigt__p_wxFlexGridSizer,
40810 &_swigt__p_wxFocusEvent,
40811 &_swigt__p_wxFont,
40812 &_swigt__p_wxFrame,
40813 &_swigt__p_wxGBSizerItem,
40814 &_swigt__p_wxGIFHandler,
40815 &_swigt__p_wxGridBagSizer,
40816 &_swigt__p_wxGridSizer,
40817 &_swigt__p_wxICOHandler,
40818 &_swigt__p_wxIcon,
40819 &_swigt__p_wxIconizeEvent,
40820 &_swigt__p_wxIdleEvent,
40821 &_swigt__p_wxImage,
40822 &_swigt__p_wxImageHandler,
40823 &_swigt__p_wxIndividualLayoutConstraint,
40824 &_swigt__p_wxInitDialogEvent,
40825 &_swigt__p_wxJPEGHandler,
40826 &_swigt__p_wxJoystick,
40827 &_swigt__p_wxJoystickEvent,
40828 &_swigt__p_wxKeyEvent,
40829 &_swigt__p_wxKillError,
40830 &_swigt__p_wxLayoutConstraints,
40831 &_swigt__p_wxLog,
40832 &_swigt__p_wxLogBuffer,
40833 &_swigt__p_wxLogChain,
40834 &_swigt__p_wxLogGui,
40835 &_swigt__p_wxLogNull,
40836 &_swigt__p_wxLogStderr,
40837 &_swigt__p_wxLogTextCtrl,
40838 &_swigt__p_wxLogWindow,
40839 &_swigt__p_wxMaximizeEvent,
40840 &_swigt__p_wxMenu,
40841 &_swigt__p_wxMenuBar,
40842 &_swigt__p_wxMenuEvent,
40843 &_swigt__p_wxMenuItem,
40844 &_swigt__p_wxMetafile,
40845 &_swigt__p_wxMetafileDataObject,
40846 &_swigt__p_wxMimeTypesManager,
40847 &_swigt__p_wxMouseCaptureChangedEvent,
40848 &_swigt__p_wxMouseCaptureLostEvent,
40849 &_swigt__p_wxMouseEvent,
40850 &_swigt__p_wxMouseState,
40851 &_swigt__p_wxMoveEvent,
40852 &_swigt__p_wxMutexGuiLocker,
40853 &_swigt__p_wxNavigationKeyEvent,
40854 &_swigt__p_wxNcPaintEvent,
40855 &_swigt__p_wxNotifyEvent,
40856 &_swigt__p_wxObject,
40857 &_swigt__p_wxOutputStream,
40858 &_swigt__p_wxPCXHandler,
40859 &_swigt__p_wxPNGHandler,
40860 &_swigt__p_wxPNMHandler,
40861 &_swigt__p_wxPaintEvent,
40862 &_swigt__p_wxPaletteChangedEvent,
40863 &_swigt__p_wxPaperSize,
40864 &_swigt__p_wxPlatformInfo,
40865 &_swigt__p_wxPoint,
40866 &_swigt__p_wxPowerEvent,
40867 &_swigt__p_wxProcessEvent,
40868 &_swigt__p_wxPyApp,
40869 &_swigt__p_wxPyArtProvider,
40870 &_swigt__p_wxPyBitmapDataObject,
40871 &_swigt__p_wxPyCommandEvent,
40872 &_swigt__p_wxPyDataObjectSimple,
40873 &_swigt__p_wxPyDropSource,
40874 &_swigt__p_wxPyDropTarget,
40875 &_swigt__p_wxPyEvent,
40876 &_swigt__p_wxPyFileDropTarget,
40877 &_swigt__p_wxPyImageHandler,
40878 &_swigt__p_wxPyLog,
40879 &_swigt__p_wxPyProcess,
40880 &_swigt__p_wxPySizer,
40881 &_swigt__p_wxPyTextDataObject,
40882 &_swigt__p_wxPyTextDropTarget,
40883 &_swigt__p_wxPyTimer,
40884 &_swigt__p_wxPyTipProvider,
40885 &_swigt__p_wxPyValidator,
40886 &_swigt__p_wxQueryNewPaletteEvent,
40887 &_swigt__p_wxRect,
40888 &_swigt__p_wxScrollEvent,
40889 &_swigt__p_wxScrollWinEvent,
40890 &_swigt__p_wxSetCursorEvent,
40891 &_swigt__p_wxShowEvent,
40892 &_swigt__p_wxSingleInstanceChecker,
40893 &_swigt__p_wxSize,
40894 &_swigt__p_wxSizeEvent,
40895 &_swigt__p_wxSizer,
40896 &_swigt__p_wxSizerItem,
40897 &_swigt__p_wxSound,
40898 &_swigt__p_wxStandardPaths,
40899 &_swigt__p_wxStaticBoxSizer,
40900 &_swigt__p_wxStdDialogButtonSizer,
40901 &_swigt__p_wxStopWatch,
40902 &_swigt__p_wxString,
40903 &_swigt__p_wxSysColourChangedEvent,
40904 &_swigt__p_wxSystemOptions,
40905 &_swigt__p_wxSystemSettings,
40906 &_swigt__p_wxTIFFHandler,
40907 &_swigt__p_wxTextCtrl,
40908 &_swigt__p_wxTextDataObject,
40909 &_swigt__p_wxTimeSpan,
40910 &_swigt__p_wxTimer,
40911 &_swigt__p_wxTimerEvent,
40912 &_swigt__p_wxTimerRunner,
40913 &_swigt__p_wxTipProvider,
40914 &_swigt__p_wxToolTip,
40915 &_swigt__p_wxURLDataObject,
40916 &_swigt__p_wxUpdateUIEvent,
40917 &_swigt__p_wxValidator,
40918 &_swigt__p_wxVideoMode,
40919 &_swigt__p_wxWindow,
40920 &_swigt__p_wxWindowCreateEvent,
40921 &_swigt__p_wxWindowDestroyEvent,
40922 &_swigt__p_wxWindowDisabler,
40923 &_swigt__p_wxXPMHandler,
40924 };
40925
40926 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
40927 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
40928 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
40929 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
40930 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
40931 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
40932 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
40933 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
40934 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
40935 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
40936 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}};
40937 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
40938 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
40939 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
40940 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
40941 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
40942 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
40943 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
40944 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
40945 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}};
40946 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
40947 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
40948 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
40949 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
40950 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
40951 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}};
40952 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
40953 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}};
40954 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
40955 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
40956 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
40957 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
40958 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
40959 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
40960 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
40961 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
40962 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
40963 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
40964 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
40965 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
40966 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
40967 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
40968 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
40969 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
40970 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
40971 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
40972 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
40973 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
40974 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
40975 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
40976 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
40977 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
40978 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
40979 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
40980 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
40981 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
40982 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
40983 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
40984 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
40985 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
40986 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
40987 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
40988 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
40989 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
40990 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
40991 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
40992 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
40993 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
40994 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
40995 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
40996 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
40997 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}};
40998 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
40999 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41000 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41001 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41002 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41003 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41004 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41005 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41006 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41007 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41008 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41009 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41010 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41011 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41012 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41013 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41014 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41015 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41016 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}};
41017 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41018 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41019 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41020 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41021 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41022 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41023 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41024 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41025 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
41026 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41027 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41028 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41029 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41030 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41031 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41032 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41033 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41034 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41035 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41036 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41037 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41038 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41039 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41040 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41041 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41042 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41043 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41044 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41045 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41046 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41047 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41048 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41049 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41050 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41051 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41052 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41053 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41054 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41055 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41058 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41059 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41060 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
41061 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41062 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41063 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41064 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41065 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41067 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41068 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41069 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41070 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41071 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}};
41072 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41073 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41074 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41075 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41076 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41079 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41080 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41081 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41089 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}};
41090 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41094 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}};
41095 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41098 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}};
41099 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41100
41101 static swig_cast_info *swig_cast_initial[] = {
41102 _swigc__p_char,
41103 _swigc__p_form_ops_t,
41104 _swigc__p_int,
41105 _swigc__p_unsigned_char,
41106 _swigc__p_unsigned_int,
41107 _swigc__p_unsigned_long,
41108 _swigc__p_void,
41109 _swigc__p_wxANIHandler,
41110 _swigc__p_wxAboutDialogInfo,
41111 _swigc__p_wxAcceleratorTable,
41112 _swigc__p_wxActivateEvent,
41113 _swigc__p_wxArrayString,
41114 _swigc__p_wxBMPHandler,
41115 _swigc__p_wxBitmap,
41116 _swigc__p_wxBitmapDataObject,
41117 _swigc__p_wxBoxSizer,
41118 _swigc__p_wxBusyCursor,
41119 _swigc__p_wxBusyInfo,
41120 _swigc__p_wxCURHandler,
41121 _swigc__p_wxCaret,
41122 _swigc__p_wxChar,
41123 _swigc__p_wxChildFocusEvent,
41124 _swigc__p_wxClipboard,
41125 _swigc__p_wxClipboardLocker,
41126 _swigc__p_wxClipboardTextEvent,
41127 _swigc__p_wxCloseEvent,
41128 _swigc__p_wxColour,
41129 _swigc__p_wxCommandEvent,
41130 _swigc__p_wxConfig,
41131 _swigc__p_wxConfigBase,
41132 _swigc__p_wxConfigPathChanger,
41133 _swigc__p_wxContextMenuEvent,
41134 _swigc__p_wxControl,
41135 _swigc__p_wxControlWithItems,
41136 _swigc__p_wxCursor,
41137 _swigc__p_wxCustomDataObject,
41138 _swigc__p_wxDC,
41139 _swigc__p_wxDataFormat,
41140 _swigc__p_wxDataObject,
41141 _swigc__p_wxDataObjectComposite,
41142 _swigc__p_wxDataObjectSimple,
41143 _swigc__p_wxDateEvent,
41144 _swigc__p_wxDateSpan,
41145 _swigc__p_wxDateTime,
41146 _swigc__p_wxDateTime__TimeZone,
41147 _swigc__p_wxDisplay,
41148 _swigc__p_wxDisplayChangedEvent,
41149 _swigc__p_wxDropFilesEvent,
41150 _swigc__p_wxDuplexMode,
41151 _swigc__p_wxEraseEvent,
41152 _swigc__p_wxEvent,
41153 _swigc__p_wxEvtHandler,
41154 _swigc__p_wxFSFile,
41155 _swigc__p_wxFileConfig,
41156 _swigc__p_wxFileDataObject,
41157 _swigc__p_wxFileHistory,
41158 _swigc__p_wxFileSystem,
41159 _swigc__p_wxFileType,
41160 _swigc__p_wxFileTypeInfo,
41161 _swigc__p_wxFlexGridSizer,
41162 _swigc__p_wxFocusEvent,
41163 _swigc__p_wxFont,
41164 _swigc__p_wxFrame,
41165 _swigc__p_wxGBSizerItem,
41166 _swigc__p_wxGIFHandler,
41167 _swigc__p_wxGridBagSizer,
41168 _swigc__p_wxGridSizer,
41169 _swigc__p_wxICOHandler,
41170 _swigc__p_wxIcon,
41171 _swigc__p_wxIconizeEvent,
41172 _swigc__p_wxIdleEvent,
41173 _swigc__p_wxImage,
41174 _swigc__p_wxImageHandler,
41175 _swigc__p_wxIndividualLayoutConstraint,
41176 _swigc__p_wxInitDialogEvent,
41177 _swigc__p_wxJPEGHandler,
41178 _swigc__p_wxJoystick,
41179 _swigc__p_wxJoystickEvent,
41180 _swigc__p_wxKeyEvent,
41181 _swigc__p_wxKillError,
41182 _swigc__p_wxLayoutConstraints,
41183 _swigc__p_wxLog,
41184 _swigc__p_wxLogBuffer,
41185 _swigc__p_wxLogChain,
41186 _swigc__p_wxLogGui,
41187 _swigc__p_wxLogNull,
41188 _swigc__p_wxLogStderr,
41189 _swigc__p_wxLogTextCtrl,
41190 _swigc__p_wxLogWindow,
41191 _swigc__p_wxMaximizeEvent,
41192 _swigc__p_wxMenu,
41193 _swigc__p_wxMenuBar,
41194 _swigc__p_wxMenuEvent,
41195 _swigc__p_wxMenuItem,
41196 _swigc__p_wxMetafile,
41197 _swigc__p_wxMetafileDataObject,
41198 _swigc__p_wxMimeTypesManager,
41199 _swigc__p_wxMouseCaptureChangedEvent,
41200 _swigc__p_wxMouseCaptureLostEvent,
41201 _swigc__p_wxMouseEvent,
41202 _swigc__p_wxMouseState,
41203 _swigc__p_wxMoveEvent,
41204 _swigc__p_wxMutexGuiLocker,
41205 _swigc__p_wxNavigationKeyEvent,
41206 _swigc__p_wxNcPaintEvent,
41207 _swigc__p_wxNotifyEvent,
41208 _swigc__p_wxObject,
41209 _swigc__p_wxOutputStream,
41210 _swigc__p_wxPCXHandler,
41211 _swigc__p_wxPNGHandler,
41212 _swigc__p_wxPNMHandler,
41213 _swigc__p_wxPaintEvent,
41214 _swigc__p_wxPaletteChangedEvent,
41215 _swigc__p_wxPaperSize,
41216 _swigc__p_wxPlatformInfo,
41217 _swigc__p_wxPoint,
41218 _swigc__p_wxPowerEvent,
41219 _swigc__p_wxProcessEvent,
41220 _swigc__p_wxPyApp,
41221 _swigc__p_wxPyArtProvider,
41222 _swigc__p_wxPyBitmapDataObject,
41223 _swigc__p_wxPyCommandEvent,
41224 _swigc__p_wxPyDataObjectSimple,
41225 _swigc__p_wxPyDropSource,
41226 _swigc__p_wxPyDropTarget,
41227 _swigc__p_wxPyEvent,
41228 _swigc__p_wxPyFileDropTarget,
41229 _swigc__p_wxPyImageHandler,
41230 _swigc__p_wxPyLog,
41231 _swigc__p_wxPyProcess,
41232 _swigc__p_wxPySizer,
41233 _swigc__p_wxPyTextDataObject,
41234 _swigc__p_wxPyTextDropTarget,
41235 _swigc__p_wxPyTimer,
41236 _swigc__p_wxPyTipProvider,
41237 _swigc__p_wxPyValidator,
41238 _swigc__p_wxQueryNewPaletteEvent,
41239 _swigc__p_wxRect,
41240 _swigc__p_wxScrollEvent,
41241 _swigc__p_wxScrollWinEvent,
41242 _swigc__p_wxSetCursorEvent,
41243 _swigc__p_wxShowEvent,
41244 _swigc__p_wxSingleInstanceChecker,
41245 _swigc__p_wxSize,
41246 _swigc__p_wxSizeEvent,
41247 _swigc__p_wxSizer,
41248 _swigc__p_wxSizerItem,
41249 _swigc__p_wxSound,
41250 _swigc__p_wxStandardPaths,
41251 _swigc__p_wxStaticBoxSizer,
41252 _swigc__p_wxStdDialogButtonSizer,
41253 _swigc__p_wxStopWatch,
41254 _swigc__p_wxString,
41255 _swigc__p_wxSysColourChangedEvent,
41256 _swigc__p_wxSystemOptions,
41257 _swigc__p_wxSystemSettings,
41258 _swigc__p_wxTIFFHandler,
41259 _swigc__p_wxTextCtrl,
41260 _swigc__p_wxTextDataObject,
41261 _swigc__p_wxTimeSpan,
41262 _swigc__p_wxTimer,
41263 _swigc__p_wxTimerEvent,
41264 _swigc__p_wxTimerRunner,
41265 _swigc__p_wxTipProvider,
41266 _swigc__p_wxToolTip,
41267 _swigc__p_wxURLDataObject,
41268 _swigc__p_wxUpdateUIEvent,
41269 _swigc__p_wxValidator,
41270 _swigc__p_wxVideoMode,
41271 _swigc__p_wxWindow,
41272 _swigc__p_wxWindowCreateEvent,
41273 _swigc__p_wxWindowDestroyEvent,
41274 _swigc__p_wxWindowDisabler,
41275 _swigc__p_wxXPMHandler,
41276 };
41277
41278
41279 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41280
41281 static swig_const_info swig_const_table[] = {
41282 {0, 0, 0, 0.0, 0, 0}};
41283
41284 #ifdef __cplusplus
41285 }
41286 #endif
41287 /* -----------------------------------------------------------------------------
41288 * Type initialization:
41289 * This problem is tough by the requirement that no dynamic
41290 * memory is used. Also, since swig_type_info structures store pointers to
41291 * swig_cast_info structures and swig_cast_info structures store pointers back
41292 * to swig_type_info structures, we need some lookup code at initialization.
41293 * The idea is that swig generates all the structures that are needed.
41294 * The runtime then collects these partially filled structures.
41295 * The SWIG_InitializeModule function takes these initial arrays out of
41296 * swig_module, and does all the lookup, filling in the swig_module.types
41297 * array with the correct data and linking the correct swig_cast_info
41298 * structures together.
41299 *
41300 * The generated swig_type_info structures are assigned staticly to an initial
41301 * array. We just loop though that array, and handle each type individually.
41302 * First we lookup if this type has been already loaded, and if so, use the
41303 * loaded structure instead of the generated one. Then we have to fill in the
41304 * cast linked list. The cast data is initially stored in something like a
41305 * two-dimensional array. Each row corresponds to a type (there are the same
41306 * number of rows as there are in the swig_type_initial array). Each entry in
41307 * a column is one of the swig_cast_info structures for that type.
41308 * The cast_initial array is actually an array of arrays, because each row has
41309 * a variable number of columns. So to actually build the cast linked list,
41310 * we find the array of casts associated with the type, and loop through it
41311 * adding the casts to the list. The one last trick we need to do is making
41312 * sure the type pointer in the swig_cast_info struct is correct.
41313 *
41314 * First off, we lookup the cast->type name to see if it is already loaded.
41315 * There are three cases to handle:
41316 * 1) If the cast->type has already been loaded AND the type we are adding
41317 * casting info to has not been loaded (it is in this module), THEN we
41318 * replace the cast->type pointer with the type pointer that has already
41319 * been loaded.
41320 * 2) If BOTH types (the one we are adding casting info to, and the
41321 * cast->type) are loaded, THEN the cast info has already been loaded by
41322 * the previous module so we just ignore it.
41323 * 3) Finally, if cast->type has not already been loaded, then we add that
41324 * swig_cast_info to the linked list (because the cast->type) pointer will
41325 * be correct.
41326 * ----------------------------------------------------------------------------- */
41327
41328 #ifdef __cplusplus
41329 extern "C" {
41330 #if 0
41331 } /* c-mode */
41332 #endif
41333 #endif
41334
41335 #if 0
41336 #define SWIGRUNTIME_DEBUG
41337 #endif
41338
41339 SWIGRUNTIME void
41340 SWIG_InitializeModule(void *clientdata) {
41341 size_t i;
41342 swig_module_info *module_head;
41343 static int init_run = 0;
41344
41345 clientdata = clientdata;
41346
41347 if (init_run) return;
41348 init_run = 1;
41349
41350 /* Initialize the swig_module */
41351 swig_module.type_initial = swig_type_initial;
41352 swig_module.cast_initial = swig_cast_initial;
41353
41354 /* Try and load any already created modules */
41355 module_head = SWIG_GetModule(clientdata);
41356 if (module_head) {
41357 swig_module.next = module_head->next;
41358 module_head->next = &swig_module;
41359 } else {
41360 /* This is the first module loaded */
41361 swig_module.next = &swig_module;
41362 SWIG_SetModule(clientdata, &swig_module);
41363 }
41364
41365 /* Now work on filling in swig_module.types */
41366 #ifdef SWIGRUNTIME_DEBUG
41367 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41368 #endif
41369 for (i = 0; i < swig_module.size; ++i) {
41370 swig_type_info *type = 0;
41371 swig_type_info *ret;
41372 swig_cast_info *cast;
41373
41374 #ifdef SWIGRUNTIME_DEBUG
41375 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41376 #endif
41377
41378 /* if there is another module already loaded */
41379 if (swig_module.next != &swig_module) {
41380 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41381 }
41382 if (type) {
41383 /* Overwrite clientdata field */
41384 #ifdef SWIGRUNTIME_DEBUG
41385 printf("SWIG_InitializeModule: found type %s\n", type->name);
41386 #endif
41387 if (swig_module.type_initial[i]->clientdata) {
41388 type->clientdata = swig_module.type_initial[i]->clientdata;
41389 #ifdef SWIGRUNTIME_DEBUG
41390 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41391 #endif
41392 }
41393 } else {
41394 type = swig_module.type_initial[i];
41395 }
41396
41397 /* Insert casting types */
41398 cast = swig_module.cast_initial[i];
41399 while (cast->type) {
41400 /* Don't need to add information already in the list */
41401 ret = 0;
41402 #ifdef SWIGRUNTIME_DEBUG
41403 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41404 #endif
41405 if (swig_module.next != &swig_module) {
41406 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41407 #ifdef SWIGRUNTIME_DEBUG
41408 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41409 #endif
41410 }
41411 if (ret) {
41412 if (type == swig_module.type_initial[i]) {
41413 #ifdef SWIGRUNTIME_DEBUG
41414 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41415 #endif
41416 cast->type = ret;
41417 ret = 0;
41418 } else {
41419 /* Check for casting already in the list */
41420 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41421 #ifdef SWIGRUNTIME_DEBUG
41422 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41423 #endif
41424 if (!ocast) ret = 0;
41425 }
41426 }
41427
41428 if (!ret) {
41429 #ifdef SWIGRUNTIME_DEBUG
41430 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41431 #endif
41432 if (type->cast) {
41433 type->cast->prev = cast;
41434 cast->next = type->cast;
41435 }
41436 type->cast = cast;
41437 }
41438 cast++;
41439 }
41440 /* Set entry in modules->types array equal to the type */
41441 swig_module.types[i] = type;
41442 }
41443 swig_module.types[i] = 0;
41444
41445 #ifdef SWIGRUNTIME_DEBUG
41446 printf("**** SWIG_InitializeModule: Cast List ******\n");
41447 for (i = 0; i < swig_module.size; ++i) {
41448 int j = 0;
41449 swig_cast_info *cast = swig_module.cast_initial[i];
41450 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41451 while (cast->type) {
41452 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41453 cast++;
41454 ++j;
41455 }
41456 printf("---- Total casts: %d\n",j);
41457 }
41458 printf("**** SWIG_InitializeModule: Cast List ******\n");
41459 #endif
41460 }
41461
41462 /* This function will propagate the clientdata field of type to
41463 * any new swig_type_info structures that have been added into the list
41464 * of equivalent types. It is like calling
41465 * SWIG_TypeClientData(type, clientdata) a second time.
41466 */
41467 SWIGRUNTIME void
41468 SWIG_PropagateClientData(void) {
41469 size_t i;
41470 swig_cast_info *equiv;
41471 static int init_run = 0;
41472
41473 if (init_run) return;
41474 init_run = 1;
41475
41476 for (i = 0; i < swig_module.size; i++) {
41477 if (swig_module.types[i]->clientdata) {
41478 equiv = swig_module.types[i]->cast;
41479 while (equiv) {
41480 if (!equiv->converter) {
41481 if (equiv->type && !equiv->type->clientdata)
41482 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41483 }
41484 equiv = equiv->next;
41485 }
41486 }
41487 }
41488 }
41489
41490 #ifdef __cplusplus
41491 #if 0
41492 {
41493 /* c-mode */
41494 #endif
41495 }
41496 #endif
41497
41498
41499
41500 #ifdef __cplusplus
41501 extern "C" {
41502 #endif
41503
41504 /* Python-specific SWIG API */
41505 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41506 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41507 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41508
41509 /* -----------------------------------------------------------------------------
41510 * global variable support code.
41511 * ----------------------------------------------------------------------------- */
41512
41513 typedef struct swig_globalvar {
41514 char *name; /* Name of global variable */
41515 PyObject *(*get_attr)(void); /* Return the current value */
41516 int (*set_attr)(PyObject *); /* Set the value */
41517 struct swig_globalvar *next;
41518 } swig_globalvar;
41519
41520 typedef struct swig_varlinkobject {
41521 PyObject_HEAD
41522 swig_globalvar *vars;
41523 } swig_varlinkobject;
41524
41525 SWIGINTERN PyObject *
41526 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41527 return PyString_FromString("<Swig global variables>");
41528 }
41529
41530 SWIGINTERN PyObject *
41531 swig_varlink_str(swig_varlinkobject *v) {
41532 PyObject *str = PyString_FromString("(");
41533 swig_globalvar *var;
41534 for (var = v->vars; var; var=var->next) {
41535 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41536 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41537 }
41538 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41539 return str;
41540 }
41541
41542 SWIGINTERN int
41543 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41544 PyObject *str = swig_varlink_str(v);
41545 fprintf(fp,"Swig global variables ");
41546 fprintf(fp,"%s\n", PyString_AsString(str));
41547 Py_DECREF(str);
41548 return 0;
41549 }
41550
41551 SWIGINTERN void
41552 swig_varlink_dealloc(swig_varlinkobject *v) {
41553 swig_globalvar *var = v->vars;
41554 while (var) {
41555 swig_globalvar *n = var->next;
41556 free(var->name);
41557 free(var);
41558 var = n;
41559 }
41560 }
41561
41562 SWIGINTERN PyObject *
41563 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41564 PyObject *res = NULL;
41565 swig_globalvar *var = v->vars;
41566 while (var) {
41567 if (strcmp(var->name,n) == 0) {
41568 res = (*var->get_attr)();
41569 break;
41570 }
41571 var = var->next;
41572 }
41573 if (res == NULL && !PyErr_Occurred()) {
41574 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41575 }
41576 return res;
41577 }
41578
41579 SWIGINTERN int
41580 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41581 int res = 1;
41582 swig_globalvar *var = v->vars;
41583 while (var) {
41584 if (strcmp(var->name,n) == 0) {
41585 res = (*var->set_attr)(p);
41586 break;
41587 }
41588 var = var->next;
41589 }
41590 if (res == 1 && !PyErr_Occurred()) {
41591 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41592 }
41593 return res;
41594 }
41595
41596 SWIGINTERN PyTypeObject*
41597 swig_varlink_type(void) {
41598 static char varlink__doc__[] = "Swig var link object";
41599 static PyTypeObject varlink_type;
41600 static int type_init = 0;
41601 if (!type_init) {
41602 const PyTypeObject tmp
41603 = {
41604 PyObject_HEAD_INIT(NULL)
41605 0, /* Number of items in variable part (ob_size) */
41606 (char *)"swigvarlink", /* Type name (tp_name) */
41607 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41608 0, /* Itemsize (tp_itemsize) */
41609 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41610 (printfunc) swig_varlink_print, /* Print (tp_print) */
41611 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41612 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41613 0, /* tp_compare */
41614 (reprfunc) swig_varlink_repr, /* tp_repr */
41615 0, /* tp_as_number */
41616 0, /* tp_as_sequence */
41617 0, /* tp_as_mapping */
41618 0, /* tp_hash */
41619 0, /* tp_call */
41620 (reprfunc)swig_varlink_str, /* tp_str */
41621 0, /* tp_getattro */
41622 0, /* tp_setattro */
41623 0, /* tp_as_buffer */
41624 0, /* tp_flags */
41625 varlink__doc__, /* tp_doc */
41626 0, /* tp_traverse */
41627 0, /* tp_clear */
41628 0, /* tp_richcompare */
41629 0, /* tp_weaklistoffset */
41630 #if PY_VERSION_HEX >= 0x02020000
41631 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41632 #endif
41633 #if PY_VERSION_HEX >= 0x02030000
41634 0, /* tp_del */
41635 #endif
41636 #ifdef COUNT_ALLOCS
41637 0,0,0,0 /* tp_alloc -> tp_next */
41638 #endif
41639 };
41640 varlink_type = tmp;
41641 varlink_type.ob_type = &PyType_Type;
41642 type_init = 1;
41643 }
41644 return &varlink_type;
41645 }
41646
41647 /* Create a variable linking object for use later */
41648 SWIGINTERN PyObject *
41649 SWIG_Python_newvarlink(void) {
41650 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41651 if (result) {
41652 result->vars = 0;
41653 }
41654 return ((PyObject*) result);
41655 }
41656
41657 SWIGINTERN void
41658 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41659 swig_varlinkobject *v = (swig_varlinkobject *) p;
41660 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41661 if (gv) {
41662 size_t size = strlen(name)+1;
41663 gv->name = (char *)malloc(size);
41664 if (gv->name) {
41665 strncpy(gv->name,name,size);
41666 gv->get_attr = get_attr;
41667 gv->set_attr = set_attr;
41668 gv->next = v->vars;
41669 }
41670 }
41671 v->vars = gv;
41672 }
41673
41674 SWIGINTERN PyObject *
41675 SWIG_globals() {
41676 static PyObject *_SWIG_globals = 0;
41677 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41678 return _SWIG_globals;
41679 }
41680
41681 /* -----------------------------------------------------------------------------
41682 * constants/methods manipulation
41683 * ----------------------------------------------------------------------------- */
41684
41685 /* Install Constants */
41686 SWIGINTERN void
41687 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41688 PyObject *obj = 0;
41689 size_t i;
41690 for (i = 0; constants[i].type; ++i) {
41691 switch(constants[i].type) {
41692 case SWIG_PY_POINTER:
41693 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41694 break;
41695 case SWIG_PY_BINARY:
41696 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41697 break;
41698 default:
41699 obj = 0;
41700 break;
41701 }
41702 if (obj) {
41703 PyDict_SetItemString(d, constants[i].name, obj);
41704 Py_DECREF(obj);
41705 }
41706 }
41707 }
41708
41709 /* -----------------------------------------------------------------------------*/
41710 /* Fix SwigMethods to carry the callback ptrs when needed */
41711 /* -----------------------------------------------------------------------------*/
41712
41713 SWIGINTERN void
41714 SWIG_Python_FixMethods(PyMethodDef *methods,
41715 swig_const_info *const_table,
41716 swig_type_info **types,
41717 swig_type_info **types_initial) {
41718 size_t i;
41719 for (i = 0; methods[i].ml_name; ++i) {
41720 const char *c = methods[i].ml_doc;
41721 if (c && (c = strstr(c, "swig_ptr: "))) {
41722 int j;
41723 swig_const_info *ci = 0;
41724 const char *name = c + 10;
41725 for (j = 0; const_table[j].type; ++j) {
41726 if (strncmp(const_table[j].name, name,
41727 strlen(const_table[j].name)) == 0) {
41728 ci = &(const_table[j]);
41729 break;
41730 }
41731 }
41732 if (ci) {
41733 size_t shift = (ci->ptype) - types;
41734 swig_type_info *ty = types_initial[shift];
41735 size_t ldoc = (c - methods[i].ml_doc);
41736 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41737 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41738 if (ndoc) {
41739 char *buff = ndoc;
41740 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41741 if (ptr) {
41742 strncpy(buff, methods[i].ml_doc, ldoc);
41743 buff += ldoc;
41744 strncpy(buff, "swig_ptr: ", 10);
41745 buff += 10;
41746 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41747 methods[i].ml_doc = ndoc;
41748 }
41749 }
41750 }
41751 }
41752 }
41753 }
41754
41755 #ifdef __cplusplus
41756 }
41757 #endif
41758
41759 /* -----------------------------------------------------------------------------*
41760 * Partial Init method
41761 * -----------------------------------------------------------------------------*/
41762
41763 #ifdef __cplusplus
41764 extern "C"
41765 #endif
41766 SWIGEXPORT void SWIG_init(void) {
41767 PyObject *m, *d;
41768
41769 /* Fix SwigMethods to carry the callback ptrs when needed */
41770 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41771
41772 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41773 d = PyModule_GetDict(m);
41774
41775 SWIG_InitializeModule(0);
41776 SWIG_InstallConstants(d,swig_const_table);
41777
41778
41779 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41780 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41781 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41782 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41783 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41784 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41785 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41786 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41787 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41788 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41789 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41790 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41791 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41792 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41793 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41794 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41795 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41796 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41797 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41798 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41799 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41800 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41801 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41802 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41803 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41804 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41805 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41806 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41807 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41808 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41809 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41810 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41811 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41812 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41813 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41814 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41815 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41816 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41817 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41818 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41819 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41820 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41821 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41822 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41823 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41824 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41825 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41826 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41827 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41828 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41829 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41830 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41831 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41832 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41833 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41834 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41835 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41836 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41837 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41838 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41839 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41840 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41841 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41842 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41843 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41844 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41845 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41846 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41847 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41848 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41849 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41850 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41851 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41852 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41853 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41854 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41855 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41856 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41857 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41858 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41859 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41860 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41861 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41862 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41863 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41864 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41865 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41866 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41867 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41868 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41869 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
41870 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
41871 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
41872 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
41873 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
41874 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
41875 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
41876 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
41877 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
41878 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
41879 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
41880 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
41881 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
41882 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
41883 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
41884 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
41885 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
41886 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
41887 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
41888 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
41889 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
41890 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
41891 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
41892 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
41893 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
41894 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
41895 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
41896 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
41897 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
41898 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
41899 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
41900 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
41901 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
41902 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
41903 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
41904 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
41905 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
41906 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
41907 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
41908 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
41909 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
41910 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
41911 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
41912 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
41913 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
41914 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
41915 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
41916 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
41917 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
41918 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
41919 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
41920 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
41921 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
41922 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
41923 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
41924 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
41925 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
41926 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
41927
41928 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
41929
41930 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
41931 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
41932 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
41933 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
41934 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
41935 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
41936 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
41937 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
41938 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
41939 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
41940 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
41941 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
41942 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
41943 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
41944 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
41945 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
41946 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
41947 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
41948 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
41949 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
41950 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
41951 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
41952 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
41953 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
41954 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
41955 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
41956 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
41957 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
41958 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
41959 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
41960 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
41961 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
41962 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
41963 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
41964 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
41965 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
41966 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
41967 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
41968 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
41969 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
41970 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
41971 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
41972 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
41973 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
41974 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
41975 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
41976 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
41977 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
41978 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
41979 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
41980 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
41981 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
41982 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
41983
41984 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
41985
41986 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
41987 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
41988 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
41989 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
41990 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
41991 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
41992 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
41993 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
41994 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
41995 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
41996 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
41997 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
41998 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
41999 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42000 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42001 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42002 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42003 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42004 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42005 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42006 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42007 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42008 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42009 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42010 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42011 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42012 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42013 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42014 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42015 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42016 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42017 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42018 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42019 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42020 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42021 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42022 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42023 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42024 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42025 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42026 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42027 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42028 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42029 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42030 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42031 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42032 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42033 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42034 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42035 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42036 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42037 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42038 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42039 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42040 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42041 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42042 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42043 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42044 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42045 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42046 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42047 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42048 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42049 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42050 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42051 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42052 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42053 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42054 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42055 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42056 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42057 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42058 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42059 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42060 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42061 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42062
42063 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42064
42065 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42066 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42067 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42068 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42069 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42070 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42071 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42072 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42073 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42074 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42075 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42076 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42077 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42078 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42079 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42080 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42081 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42082 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42083 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42084 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42085 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42086 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42087 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42088 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42089 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42090 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42091 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42092 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42093 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42094 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42095 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42096 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42097 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42098 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42099 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42100 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42101 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42102 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42103 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42104 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42105 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42106 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42107 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42108 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42109 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42110 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42111 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42112 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42113 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42114 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42115 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42116 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42117 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42118 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42119 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42120 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42121 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42122 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42123 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42124 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42125 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42126 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42127 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42128 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42129 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42130 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42131 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42132 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42133 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42134 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42135 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42136 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42137 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42138 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42139 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42140 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42141 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42142 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42143 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42144 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42145 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42146 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42147 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42148 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42149 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42150 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42151 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42152 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42153 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42154 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42155 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42156 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42157 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42158 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42159 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42160 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42161 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42162 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42163 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42164 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42165 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42166 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42167 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42168 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42169 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42170 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42171 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42172 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42173 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42174 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42175 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42176 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42177 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42178 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42179 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42180 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42181 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42182 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42183 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42184 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42185 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42186 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42187 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42188 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42189 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42190 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42191 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42192 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42193 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42194 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42195 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42196 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42197 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42198 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42199 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42200 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42201 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42202 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42203 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42204 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42205 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42206 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42207 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42208 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42209 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42210 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42211 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42212 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42213 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42214 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42215 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42216 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42217 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42218 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42219 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42220 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42221 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42222 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42223 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42224 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42225 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42226 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42227 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42228 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42229 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42230 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42231 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42232 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42233 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42234 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42235 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42236 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42237 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42238 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42239 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42240 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42241 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42242 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42243 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42244 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42245 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42246 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42247 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42248 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42249 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42250 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42251 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42252 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42253 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42254 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42255 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42256 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42257 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42258 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42259 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42260 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42261 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42262 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42263 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42264 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42265
42266 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42267 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42268 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42269 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42270
42271 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42272 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42273 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42274 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42275 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42276 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42277 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42278 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42279 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42280 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42281 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42282 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42283 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42284 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42285 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42286 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42287 }
42288
wxWidgets (Impactor)