]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fix asserts for dropdown items
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_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_wxArtClient swig_types[12]
2479 #define SWIGTYPE_p_wxArtID swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBitmapDataObject swig_types[16]
2483 #define SWIGTYPE_p_wxBoxSizer swig_types[17]
2484 #define SWIGTYPE_p_wxBusyCursor swig_types[18]
2485 #define SWIGTYPE_p_wxBusyInfo swig_types[19]
2486 #define SWIGTYPE_p_wxCURHandler swig_types[20]
2487 #define SWIGTYPE_p_wxCaret swig_types[21]
2488 #define SWIGTYPE_p_wxChar swig_types[22]
2489 #define SWIGTYPE_p_wxChildFocusEvent swig_types[23]
2490 #define SWIGTYPE_p_wxClipboard swig_types[24]
2491 #define SWIGTYPE_p_wxClipboardLocker swig_types[25]
2492 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[26]
2493 #define SWIGTYPE_p_wxCloseEvent swig_types[27]
2494 #define SWIGTYPE_p_wxColour swig_types[28]
2495 #define SWIGTYPE_p_wxCommandEvent swig_types[29]
2496 #define SWIGTYPE_p_wxConfig swig_types[30]
2497 #define SWIGTYPE_p_wxConfigBase swig_types[31]
2498 #define SWIGTYPE_p_wxConfigPathChanger swig_types[32]
2499 #define SWIGTYPE_p_wxContextMenuEvent swig_types[33]
2500 #define SWIGTYPE_p_wxControl swig_types[34]
2501 #define SWIGTYPE_p_wxControlWithItems swig_types[35]
2502 #define SWIGTYPE_p_wxCursor swig_types[36]
2503 #define SWIGTYPE_p_wxCustomDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDC swig_types[38]
2505 #define SWIGTYPE_p_wxDataFormat swig_types[39]
2506 #define SWIGTYPE_p_wxDataObject swig_types[40]
2507 #define SWIGTYPE_p_wxDataObjectComposite swig_types[41]
2508 #define SWIGTYPE_p_wxDataObjectSimple swig_types[42]
2509 #define SWIGTYPE_p_wxDateEvent swig_types[43]
2510 #define SWIGTYPE_p_wxDateSpan swig_types[44]
2511 #define SWIGTYPE_p_wxDateTime swig_types[45]
2512 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[46]
2513 #define SWIGTYPE_p_wxDisplay swig_types[47]
2514 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[48]
2515 #define SWIGTYPE_p_wxDropFilesEvent swig_types[49]
2516 #define SWIGTYPE_p_wxDuplexMode swig_types[50]
2517 #define SWIGTYPE_p_wxEraseEvent swig_types[51]
2518 #define SWIGTYPE_p_wxEvent swig_types[52]
2519 #define SWIGTYPE_p_wxEventBlocker swig_types[53]
2520 #define SWIGTYPE_p_wxEvtHandler swig_types[54]
2521 #define SWIGTYPE_p_wxFSFile swig_types[55]
2522 #define SWIGTYPE_p_wxFileConfig swig_types[56]
2523 #define SWIGTYPE_p_wxFileDataObject swig_types[57]
2524 #define SWIGTYPE_p_wxFileHistory swig_types[58]
2525 #define SWIGTYPE_p_wxFileSystem swig_types[59]
2526 #define SWIGTYPE_p_wxFileType swig_types[60]
2527 #define SWIGTYPE_p_wxFileTypeInfo swig_types[61]
2528 #define SWIGTYPE_p_wxFlexGridSizer swig_types[62]
2529 #define SWIGTYPE_p_wxFocusEvent swig_types[63]
2530 #define SWIGTYPE_p_wxFont swig_types[64]
2531 #define SWIGTYPE_p_wxFrame swig_types[65]
2532 #define SWIGTYPE_p_wxGBSizerItem swig_types[66]
2533 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
2534 #define SWIGTYPE_p_wxGridBagSizer swig_types[68]
2535 #define SWIGTYPE_p_wxGridSizer swig_types[69]
2536 #define SWIGTYPE_p_wxICOHandler swig_types[70]
2537 #define SWIGTYPE_p_wxIcon swig_types[71]
2538 #define SWIGTYPE_p_wxIconBundle swig_types[72]
2539 #define SWIGTYPE_p_wxIconizeEvent swig_types[73]
2540 #define SWIGTYPE_p_wxIdleEvent swig_types[74]
2541 #define SWIGTYPE_p_wxImage swig_types[75]
2542 #define SWIGTYPE_p_wxImageHandler swig_types[76]
2543 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[77]
2544 #define SWIGTYPE_p_wxInitDialogEvent swig_types[78]
2545 #define SWIGTYPE_p_wxJPEGHandler swig_types[79]
2546 #define SWIGTYPE_p_wxJoystick swig_types[80]
2547 #define SWIGTYPE_p_wxJoystickEvent swig_types[81]
2548 #define SWIGTYPE_p_wxKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxKillError swig_types[83]
2550 #define SWIGTYPE_p_wxLayoutConstraints swig_types[84]
2551 #define SWIGTYPE_p_wxLog swig_types[85]
2552 #define SWIGTYPE_p_wxLogBuffer swig_types[86]
2553 #define SWIGTYPE_p_wxLogChain swig_types[87]
2554 #define SWIGTYPE_p_wxLogGui swig_types[88]
2555 #define SWIGTYPE_p_wxLogNull swig_types[89]
2556 #define SWIGTYPE_p_wxLogStderr swig_types[90]
2557 #define SWIGTYPE_p_wxLogTextCtrl swig_types[91]
2558 #define SWIGTYPE_p_wxLogWindow swig_types[92]
2559 #define SWIGTYPE_p_wxMaximizeEvent swig_types[93]
2560 #define SWIGTYPE_p_wxMenu swig_types[94]
2561 #define SWIGTYPE_p_wxMenuBar swig_types[95]
2562 #define SWIGTYPE_p_wxMenuEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMenuItem swig_types[97]
2564 #define SWIGTYPE_p_wxMetafileDataObject swig_types[98]
2565 #define SWIGTYPE_p_wxMimeTypesManager swig_types[99]
2566 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[101]
2568 #define SWIGTYPE_p_wxMouseEvent swig_types[102]
2569 #define SWIGTYPE_p_wxMouseState swig_types[103]
2570 #define SWIGTYPE_p_wxMoveEvent swig_types[104]
2571 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[105]
2572 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[106]
2573 #define SWIGTYPE_p_wxNcPaintEvent swig_types[107]
2574 #define SWIGTYPE_p_wxNotifyEvent swig_types[108]
2575 #define SWIGTYPE_p_wxObject swig_types[109]
2576 #define SWIGTYPE_p_wxOutputStream swig_types[110]
2577 #define SWIGTYPE_p_wxPCXHandler swig_types[111]
2578 #define SWIGTYPE_p_wxPNGHandler swig_types[112]
2579 #define SWIGTYPE_p_wxPNMHandler swig_types[113]
2580 #define SWIGTYPE_p_wxPaintEvent swig_types[114]
2581 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[115]
2582 #define SWIGTYPE_p_wxPaperSize swig_types[116]
2583 #define SWIGTYPE_p_wxPlatformInfo swig_types[117]
2584 #define SWIGTYPE_p_wxPoint swig_types[118]
2585 #define SWIGTYPE_p_wxPowerEvent swig_types[119]
2586 #define SWIGTYPE_p_wxProcessEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyApp swig_types[121]
2588 #define SWIGTYPE_p_wxPyArtProvider swig_types[122]
2589 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[123]
2590 #define SWIGTYPE_p_wxPyCommandEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[125]
2592 #define SWIGTYPE_p_wxPyDropSource swig_types[126]
2593 #define SWIGTYPE_p_wxPyDropTarget swig_types[127]
2594 #define SWIGTYPE_p_wxPyEvent swig_types[128]
2595 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[129]
2596 #define SWIGTYPE_p_wxPyImageHandler swig_types[130]
2597 #define SWIGTYPE_p_wxPyLog swig_types[131]
2598 #define SWIGTYPE_p_wxPyProcess swig_types[132]
2599 #define SWIGTYPE_p_wxPySizer swig_types[133]
2600 #define SWIGTYPE_p_wxPyTextDataObject swig_types[134]
2601 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[135]
2602 #define SWIGTYPE_p_wxPyTimer swig_types[136]
2603 #define SWIGTYPE_p_wxPyTipProvider swig_types[137]
2604 #define SWIGTYPE_p_wxPyValidator swig_types[138]
2605 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[139]
2606 #define SWIGTYPE_p_wxRect swig_types[140]
2607 #define SWIGTYPE_p_wxScrollEvent swig_types[141]
2608 #define SWIGTYPE_p_wxScrollWinEvent swig_types[142]
2609 #define SWIGTYPE_p_wxSetCursorEvent swig_types[143]
2610 #define SWIGTYPE_p_wxShowEvent swig_types[144]
2611 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[145]
2612 #define SWIGTYPE_p_wxSize swig_types[146]
2613 #define SWIGTYPE_p_wxSizeEvent swig_types[147]
2614 #define SWIGTYPE_p_wxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxSizerItem swig_types[149]
2616 #define SWIGTYPE_p_wxSound swig_types[150]
2617 #define SWIGTYPE_p_wxStandardPaths swig_types[151]
2618 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[152]
2619 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[153]
2620 #define SWIGTYPE_p_wxStopWatch swig_types[154]
2621 #define SWIGTYPE_p_wxString swig_types[155]
2622 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[156]
2623 #define SWIGTYPE_p_wxSystemOptions swig_types[157]
2624 #define SWIGTYPE_p_wxSystemSettings swig_types[158]
2625 #define SWIGTYPE_p_wxTGAHandler swig_types[159]
2626 #define SWIGTYPE_p_wxTIFFHandler swig_types[160]
2627 #define SWIGTYPE_p_wxTextCtrl swig_types[161]
2628 #define SWIGTYPE_p_wxTextDataObject swig_types[162]
2629 #define SWIGTYPE_p_wxTimeSpan swig_types[163]
2630 #define SWIGTYPE_p_wxTimer swig_types[164]
2631 #define SWIGTYPE_p_wxTimerEvent swig_types[165]
2632 #define SWIGTYPE_p_wxTimerRunner swig_types[166]
2633 #define SWIGTYPE_p_wxTipProvider swig_types[167]
2634 #define SWIGTYPE_p_wxToolTip swig_types[168]
2635 #define SWIGTYPE_p_wxURLDataObject swig_types[169]
2636 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[170]
2637 #define SWIGTYPE_p_wxValidator swig_types[171]
2638 #define SWIGTYPE_p_wxVideoMode swig_types[172]
2639 #define SWIGTYPE_p_wxWindow swig_types[173]
2640 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[174]
2641 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[175]
2642 #define SWIGTYPE_p_wxWindowDisabler swig_types[176]
2643 #define SWIGTYPE_p_wxXPMHandler swig_types[177]
2644 static swig_type_info *swig_types[179];
2645 static swig_module_info swig_module = {swig_types, 178, 0, 0, 0, 0};
2646 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2647 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2648
2649 /* -------- TYPES TABLE (END) -------- */
2650
2651 #if (PY_VERSION_HEX <= 0x02000000)
2652 # if !defined(SWIG_PYTHON_CLASSIC)
2653 # error "This python version requires to use swig with the '-classic' option"
2654 # endif
2655 #endif
2656 #if (PY_VERSION_HEX <= 0x02020000)
2657 # error "This python version requires to use swig with the '-nomodern' option"
2658 #endif
2659 #if (PY_VERSION_HEX <= 0x02020000)
2660 # error "This python version requires to use swig with the '-nomodernargs' option"
2661 #endif
2662 #ifndef METH_O
2663 # error "This python version requires to use swig with the '-nofastunpack' option"
2664 #endif
2665
2666 /*-----------------------------------------------
2667 @(target):= _misc_.so
2668 ------------------------------------------------*/
2669 #define SWIG_init init_misc_
2670
2671 #define SWIG_name "_misc_"
2672
2673 #define SWIGVERSION 0x010329
2674
2675
2676 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2677 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2678
2679
2680 #include <stdexcept>
2681
2682
2683 namespace swig {
2684 class PyObject_ptr {
2685 protected:
2686 PyObject *_obj;
2687
2688 public:
2689 PyObject_ptr() :_obj(0)
2690 {
2691 }
2692
2693 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2694 {
2695 Py_XINCREF(_obj);
2696 }
2697
2698 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2699 {
2700 if (initial_ref) Py_XINCREF(_obj);
2701 }
2702
2703 PyObject_ptr & operator=(const PyObject_ptr& item)
2704 {
2705 Py_XINCREF(item._obj);
2706 Py_XDECREF(_obj);
2707 _obj = item._obj;
2708 return *this;
2709 }
2710
2711 ~PyObject_ptr()
2712 {
2713 Py_XDECREF(_obj);
2714 }
2715
2716 operator PyObject *() const
2717 {
2718 return _obj;
2719 }
2720
2721 PyObject *operator->() const
2722 {
2723 return _obj;
2724 }
2725 };
2726 }
2727
2728
2729 namespace swig {
2730 struct PyObject_var : PyObject_ptr {
2731 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2732
2733 PyObject_var & operator = (PyObject* obj)
2734 {
2735 Py_XDECREF(_obj);
2736 _obj = obj;
2737 return *this;
2738 }
2739 };
2740 }
2741
2742
2743 #include "wx/wxPython/wxPython.h"
2744 #include "wx/wxPython/pyclasses.h"
2745 #include "wx/wxPython/pyistream.h"
2746
2747 static const wxString wxPyEmptyString(wxEmptyString);
2748
2749
2750
2751 #define SWIG_From_long PyInt_FromLong
2752
2753
2754 SWIGINTERNINLINE PyObject *
2755 SWIG_From_int (int value)
2756 {
2757 return SWIG_From_long (value);
2758 }
2759
2760
2761 #include <limits.h>
2762 #ifndef LLONG_MIN
2763 # define LLONG_MIN LONG_LONG_MIN
2764 #endif
2765 #ifndef LLONG_MAX
2766 # define LLONG_MAX LONG_LONG_MAX
2767 #endif
2768 #ifndef ULLONG_MAX
2769 # define ULLONG_MAX ULONG_LONG_MAX
2770 #endif
2771
2772
2773 SWIGINTERN int
2774 SWIG_AsVal_long (PyObject* obj, long* val)
2775 {
2776 if (PyNumber_Check(obj)) {
2777 if (val) *val = PyInt_AsLong(obj);
2778 return SWIG_OK;
2779 }
2780 return SWIG_TypeError;
2781 }
2782
2783
2784 SWIGINTERN int
2785 SWIG_AsVal_int (PyObject * obj, int *val)
2786 {
2787 long v;
2788 int res = SWIG_AsVal_long (obj, &v);
2789 if (SWIG_IsOK(res)) {
2790 if ((v < INT_MIN || v > INT_MAX)) {
2791 return SWIG_OverflowError;
2792 } else {
2793 if (val) *val = static_cast< int >(v);
2794 }
2795 }
2796 return res;
2797 }
2798
2799 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2800
2801 #include <wx/stockitem.h>
2802
2803 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2804 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2805 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2806
2807 wxMemorySize wxGetFreeMemory()
2808 { wxPyRaiseNotImplemented(); return 0; }
2809
2810
2811 SWIGINTERN int
2812 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2813 {
2814 long v = 0;
2815 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2816 return SWIG_TypeError;
2817 }
2818 else if (val)
2819 *val = (unsigned long)v;
2820 return SWIG_OK;
2821 }
2822
2823
2824 SWIGINTERN int
2825 SWIG_AsVal_bool (PyObject *obj, bool *val)
2826 {
2827 if (obj == Py_True) {
2828 if (val) *val = true;
2829 return SWIG_OK;
2830 } else if (obj == Py_False) {
2831 if (val) *val = false;
2832 return SWIG_OK;
2833 } else {
2834 long v = 0;
2835 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2836 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2837 return res;
2838 }
2839 }
2840
2841
2842 SWIGINTERNINLINE PyObject*
2843 SWIG_From_unsigned_SS_long (unsigned long value)
2844 {
2845 return (value > LONG_MAX) ?
2846 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2847 }
2848
2849
2850 void* wxGetXDisplay()
2851 {
2852 #ifdef __WXGTK__
2853 return wxGetDisplay();
2854 #else
2855 return NULL;
2856 #endif
2857 }
2858
2859
2860 wxWindow* FindWindowAtPointer() {
2861 wxPoint unused;
2862 return wxFindWindowAtPointer(unused);
2863 }
2864
2865
2866 void wxWakeUpMainThread() {}
2867
2868
2869 bool wxThread_IsMain() {
2870 #ifdef WXP_WITH_THREAD
2871 return wxThread::IsMain();
2872 #else
2873 return true;
2874 #endif
2875 }
2876
2877 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2878 delete self;
2879 }
2880
2881 #include <wx/snglinst.h>
2882
2883
2884 #ifdef __WXMSW__
2885 #include <wx/msw/private.h>
2886 #include <wx/dynload.h>
2887 #endif
2888
2889
2890
2891 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2892 #if 0
2893 , int method
2894 #endif
2895 )
2896 {
2897 #ifdef __WXMSW__
2898 #if 0
2899 switch (method)
2900 {
2901 case 1:
2902 // This one only partially works. Appears to be an undocumented
2903 // "standard" convention that not all widgets adhear to. For
2904 // example, for some widgets backgrounds or non-client areas may
2905 // not be painted.
2906 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2907 break;
2908
2909 case 2:
2910 #endif
2911 // This one works much better, nearly all widgets and their
2912 // children are captured correctly[**]. Prior to the big
2913 // background erase changes that Vadim did in 2004-2005 this
2914 // method failed badly on XP with Themes activated, most native
2915 // widgets draw only partially, if at all. Without themes it
2916 // worked just like on Win2k. After those changes this method
2917 // works very well.
2918 //
2919 // ** For example the radio buttons in a wxRadioBox are not its
2920 // children by default, but you can capture it via the panel
2921 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2922 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2923 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2924 PRF_ERASEBKGND | PRF_OWNED );
2925 return true;
2926 #if 0
2927 break;
2928
2929 case 3:
2930 // This one is only defined in the latest SDK and is only
2931 // available on XP. MSDN says it is similar to sending WM_PRINT
2932 // so I expect that it will work similar to the above. Since it
2933 // is avaialble only on XP, it can't be compiled like this and
2934 // will have to be loaded dynamically.
2935 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2936
2937 // fall through
2938
2939 case 4:
2940 // Use PrintWindow if available, or fallback to WM_PRINT
2941 // otherwise. Unfortunately using PrintWindow is even worse than
2942 // WM_PRINT. For most native widgets nothing is drawn to the dc
2943 // at all, with or without Themes.
2944 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2945 static bool s_triedToLoad = false;
2946 static PrintWindow_t pfnPrintWindow = NULL;
2947 if ( !s_triedToLoad )
2948 {
2949
2950 s_triedToLoad = true;
2951 wxDynamicLibrary dllUser32(_T("user32.dll"));
2952 if ( dllUser32.IsLoaded() )
2953 {
2954 wxLogNull nolog; // Don't report errors here
2955 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2956 }
2957 }
2958 if (pfnPrintWindow)
2959 {
2960 //printf("Using PrintWindow\n");
2961 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2962 }
2963 else
2964 {
2965 //printf("Using WM_PRINT\n");
2966 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2967 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2968 PRF_ERASEBKGND | PRF_OWNED );
2969 }
2970 }
2971 #endif // 0
2972 #else
2973 return false;
2974 #endif // __WXMSW__
2975 }
2976
2977
2978
2979 #include <wx/tipdlg.h>
2980
2981
2982 SWIGINTERNINLINE PyObject *
2983 SWIG_From_size_t (size_t value)
2984 {
2985 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2986 }
2987
2988
2989 class wxPyTipProvider : public wxTipProvider {
2990 public:
2991 wxPyTipProvider(size_t currentTip)
2992 : wxTipProvider(currentTip) {}
2993
2994 DEC_PYCALLBACK_STRING__pure(GetTip);
2995 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2996 PYPRIVATE;
2997 };
2998
2999 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
3000 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
3001
3002
3003 SWIGINTERNINLINE int
3004 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3005 {
3006 unsigned long v;
3007 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3008 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3009 return res;
3010 }
3011
3012
3013 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3014
3015 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3016
3017 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3018 : wxTimer(owner, id)
3019 {
3020 if (owner == NULL)
3021 SetOwner(this);
3022 }
3023
3024 wxPyTimer::~wxPyTimer()
3025 {
3026 // printf("-=* ~wxPyTimer\n");
3027 }
3028
3029
3030
3031 SWIGINTERN swig_type_info*
3032 SWIG_pchar_descriptor()
3033 {
3034 static int init = 0;
3035 static swig_type_info* info = 0;
3036 if (!init) {
3037 info = SWIG_TypeQuery("_p_char");
3038 init = 1;
3039 }
3040 return info;
3041 }
3042
3043
3044 SWIGINTERNINLINE PyObject *
3045 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3046 {
3047 if (carray) {
3048 if (size > INT_MAX) {
3049 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3050 return pchar_descriptor ?
3051 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3052 } else {
3053 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3054 }
3055 } else {
3056 return SWIG_Py_Void();
3057 }
3058 }
3059
3060
3061 SWIGINTERNINLINE PyObject *
3062 SWIG_FromCharPtr(const char *cptr)
3063 {
3064 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3065 }
3066
3067
3068 SWIGINTERN int
3069 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3070 {
3071 unsigned long v;
3072 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3073 if (SWIG_IsOK(res)) {
3074 if ((v > UINT_MAX)) {
3075 return SWIG_OverflowError;
3076 } else {
3077 if (val) *val = static_cast< unsigned int >(v);
3078 }
3079 }
3080 return res;
3081 }
3082
3083 SWIGINTERN wxString wxLog_TimeStamp(){
3084 wxString msg;
3085 wxLog::TimeStamp(&msg);
3086 return msg;
3087 }
3088 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3089 // Make some wrappers that double any % signs so they are 'escaped'
3090 void wxPyLogFatalError(const wxString& msg)
3091 {
3092 wxString m(msg);
3093 m.Replace(wxT("%"), wxT("%%"));
3094 wxLogFatalError(m);
3095 }
3096
3097 void wxPyLogError(const wxString& msg)
3098 {
3099 wxString m(msg);
3100 m.Replace(wxT("%"), wxT("%%"));
3101 wxLogError(m);
3102 }
3103
3104 void wxPyLogWarning(const wxString& msg)
3105 {
3106 wxString m(msg);
3107 m.Replace(wxT("%"), wxT("%%"));
3108 wxLogWarning(m);
3109 }
3110
3111 void wxPyLogMessage(const wxString& msg)
3112 {
3113 wxString m(msg);
3114 m.Replace(wxT("%"), wxT("%%"));
3115 wxLogMessage(m);
3116 }
3117
3118 void wxPyLogInfo(const wxString& msg)
3119 {
3120 wxString m(msg);
3121 m.Replace(wxT("%"), wxT("%%"));
3122 wxLogInfo(m);
3123 }
3124
3125 void wxPyLogDebug(const wxString& msg)
3126 {
3127 wxString m(msg);
3128 m.Replace(wxT("%"), wxT("%%"));
3129 wxLogDebug(m);
3130 }
3131
3132 void wxPyLogVerbose(const wxString& msg)
3133 {
3134 wxString m(msg);
3135 m.Replace(wxT("%"), wxT("%%"));
3136 wxLogVerbose(m);
3137 }
3138
3139 void wxPyLogStatus(const wxString& msg)
3140 {
3141 wxString m(msg);
3142 m.Replace(wxT("%"), wxT("%%"));
3143 wxLogStatus(m);
3144 }
3145
3146 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3147 {
3148 wxString m(msg);
3149 m.Replace(wxT("%"), wxT("%%"));
3150 wxLogStatus(pFrame, m);
3151 }
3152
3153 void wxPyLogSysError(const wxString& msg)
3154 {
3155 wxString m(msg);
3156 m.Replace(wxT("%"), wxT("%%"));
3157 wxLogSysError(m);
3158 }
3159
3160 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3161 {
3162 wxString m(msg);
3163 m.Replace(wxT("%"), wxT("%%"));
3164 wxLogGeneric(level, m);
3165 }
3166
3167 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3168 {
3169 wxString m(msg);
3170 m.Replace(wxT("%"), wxT("%%"));
3171 wxLogTrace(mask, m);
3172 }
3173
3174 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3175 {
3176 wxString m(msg);
3177 m.Replace(wxT("%"), wxT("%%"));
3178 wxLogTrace(mask, m);
3179 }
3180
3181
3182
3183 // A wxLog class that can be derived from in wxPython
3184 class wxPyLog : public wxLog {
3185 public:
3186 wxPyLog() : wxLog() {}
3187
3188 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3189 bool found;
3190 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3191 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3192 PyObject* s = wx2PyString(szString);
3193 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3194 Py_DECREF(s);
3195 }
3196 wxPyEndBlockThreads(blocked);
3197 if (! found)
3198 wxLog::DoLog(level, szString, t);
3199 }
3200
3201 virtual void DoLogString(const wxChar *szString, time_t t) {
3202 bool found;
3203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3204 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3205 PyObject* s = wx2PyString(szString);
3206 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3207 Py_DECREF(s);
3208 }
3209 wxPyEndBlockThreads(blocked);
3210 if (! found)
3211 wxLog::DoLogString(szString, t);
3212 }
3213
3214 DEC_PYCALLBACK_VOID_(Flush);
3215 PYPRIVATE;
3216 };
3217 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3218
3219
3220
3221
3222 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3223
3224
3225 #include <wx/joystick.h>
3226
3227
3228 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3229 // A C++ stub class for wxJoystick for platforms that don't have it.
3230 class wxJoystick : public wxObject {
3231 public:
3232 wxJoystick(int joystick = wxJOYSTICK1) {
3233 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3234 PyErr_SetString(PyExc_NotImplementedError,
3235 "wxJoystick is not available on this platform.");
3236 wxPyEndBlockThreads(blocked);
3237 }
3238 wxPoint GetPosition() { return wxPoint(-1,-1); }
3239 int GetZPosition() { return -1; }
3240 int GetButtonState() { return -1; }
3241 int GetPOVPosition() { return -1; }
3242 int GetPOVCTSPosition() { return -1; }
3243 int GetRudderPosition() { return -1; }
3244 int GetUPosition() { return -1; }
3245 int GetVPosition() { return -1; }
3246 int GetMovementThreshold() { return -1; }
3247 void SetMovementThreshold(int threshold) {}
3248
3249 bool IsOk(void) { return false; }
3250 int GetNumberJoysticks() { return -1; }
3251 int GetManufacturerId() { return -1; }
3252 int GetProductId() { return -1; }
3253 wxString GetProductName() { return wxEmptyString; }
3254 int GetXMin() { return -1; }
3255 int GetYMin() { return -1; }
3256 int GetZMin() { return -1; }
3257 int GetXMax() { return -1; }
3258 int GetYMax() { return -1; }
3259 int GetZMax() { return -1; }
3260 int GetNumberButtons() { return -1; }
3261 int GetNumberAxes() { return -1; }
3262 int GetMaxButtons() { return -1; }
3263 int GetMaxAxes() { return -1; }
3264 int GetPollingMin() { return -1; }
3265 int GetPollingMax() { return -1; }
3266 int GetRudderMin() { return -1; }
3267 int GetRudderMax() { return -1; }
3268 int GetUMin() { return -1; }
3269 int GetUMax() { return -1; }
3270 int GetVMin() { return -1; }
3271 int GetVMax() { return -1; }
3272
3273 bool HasRudder() { return false; }
3274 bool HasZ() { return false; }
3275 bool HasU() { return false; }
3276 bool HasV() { return false; }
3277 bool HasPOV() { return false; }
3278 bool HasPOV4Dir() { return false; }
3279 bool HasPOVCTS() { return false; }
3280
3281 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3282 bool ReleaseCapture() { return false; }
3283 };
3284 #endif
3285
3286
3287 #include <wx/sound.h>
3288
3289
3290 #if !wxUSE_SOUND
3291 // A C++ stub class for wxWave for platforms that don't have it.
3292
3293 enum wxSoundFlags
3294 {
3295 wxSOUND_SYNC,
3296 wxSOUND_ASYNC,
3297 wxSOUND_LOOP
3298 };
3299
3300 class wxSound : public wxObject
3301 {
3302 public:
3303 wxSound() {
3304 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3305 PyErr_SetString(PyExc_NotImplementedError,
3306 "wxSound is not available on this platform.");
3307 wxPyEndBlockThreads(blocked);
3308 }
3309 wxSound(const wxString&/*, bool*/) {
3310 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3311 PyErr_SetString(PyExc_NotImplementedError,
3312 "wxSound is not available on this platform.");
3313 wxPyEndBlockThreads(blocked);
3314 }
3315 wxSound(int, const wxByte*) {
3316 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3317 PyErr_SetString(PyExc_NotImplementedError,
3318 "wxSound is not available on this platform.");
3319 wxPyEndBlockThreads(blocked);
3320 }
3321
3322 ~wxSound() {};
3323
3324 bool Create(const wxString&/*, bool*/) { return false; }
3325 bool Create(int, const wxByte*) { return false; };
3326 bool IsOk() { return false; };
3327 bool Play(unsigned) const { return false; }
3328 static bool Play(const wxString&, unsigned) { return false; }
3329 static void Stop() {}
3330 };
3331
3332 #endif
3333
3334 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3335 if (fileName.Length() == 0)
3336 return new wxSound;
3337 else
3338 return new wxSound(fileName);
3339 }
3340 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3341 unsigned char* buffer; int size;
3342 wxSound *sound = NULL;
3343
3344 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3345 if (!PyArg_Parse(data, "t#", &buffer, &size))
3346 goto done;
3347 sound = new wxSound(size, buffer);
3348 done:
3349 wxPyEndBlockThreads(blocked);
3350 return sound;
3351 }
3352 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3353 #ifndef __WXMAC__
3354 unsigned char* buffer;
3355 int size;
3356 bool rv = false;
3357
3358 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3359 if (!PyArg_Parse(data, "t#", &buffer, &size))
3360 goto done;
3361 rv = self->Create(size, buffer);
3362 done:
3363 wxPyEndBlockThreads(blocked);
3364 return rv;
3365 #else
3366 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3367 PyErr_SetString(PyExc_NotImplementedError,
3368 "Create from data is not available on this platform.");
3369 wxPyEndBlockThreads(blocked);
3370 return false;
3371 #endif
3372 }
3373
3374 #include <wx/mimetype.h>
3375
3376 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3377 wxString str;
3378 if (self->GetMimeType(&str))
3379 return wx2PyString(str);
3380 else
3381 RETURN_NONE();
3382 }
3383 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3384 wxArrayString arr;
3385 if (self->GetMimeTypes(arr))
3386 return wxArrayString2PyList_helper(arr);
3387 else
3388 RETURN_NONE();
3389 }
3390 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3391 wxArrayString arr;
3392 if (self->GetExtensions(arr))
3393 return wxArrayString2PyList_helper(arr);
3394 else
3395 RETURN_NONE();
3396 }
3397 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3398 wxIconLocation loc;
3399 if (self->GetIcon(&loc))
3400 return new wxIcon(loc);
3401 else
3402 return NULL;
3403 }
3404 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3405 wxIconLocation loc;
3406 if (self->GetIcon(&loc)) {
3407 wxString iconFile = loc.GetFileName();
3408 int iconIndex = -1;
3409
3410
3411
3412 // Make a tuple and put the values in it
3413 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3414 PyObject* tuple = PyTuple_New(3);
3415 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3416 wxT("wxIcon"), true));
3417 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3418 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3419 wxPyEndBlockThreads(blocked);
3420 return tuple;
3421 }
3422 else
3423 RETURN_NONE();
3424 }
3425 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3426 wxString str;
3427 if (self->GetDescription(&str))
3428 return wx2PyString(str);
3429 else
3430 RETURN_NONE();
3431 }
3432 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3433 wxString str;
3434 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3435 return wx2PyString(str);
3436 else
3437 RETURN_NONE();
3438 }
3439 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3440 wxString str;
3441 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3442 return wx2PyString(str);
3443 else
3444 RETURN_NONE();
3445 }
3446 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3447 wxArrayString verbs;
3448 wxArrayString commands;
3449 if (self->GetAllCommands(&verbs, &commands,
3450 wxFileType::MessageParameters(filename, mimetype))) {
3451 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3452 PyObject* tuple = PyTuple_New(2);
3453 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3454 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3455 wxPyEndBlockThreads(blocked);
3456 return tuple;
3457 }
3458 else
3459 RETURN_NONE();
3460 }
3461 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3462 return wxFileType::ExpandCommand(command,
3463 wxFileType::MessageParameters(filename, mimetype));
3464 }
3465 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3466 wxArrayString arr;
3467 self->EnumAllFileTypes(arr);
3468 return wxArrayString2PyList_helper(arr);
3469 }
3470
3471 #include <wx/artprov.h>
3472
3473 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3474 static const wxString wxPyART_MENU(wxART_MENU);
3475 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3476 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3477 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3478 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3479 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3480 static const wxString wxPyART_LIST(wxART_LIST);
3481 static const wxString wxPyART_OTHER(wxART_OTHER);
3482 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3483 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3484 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3485 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3486 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3487 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3488 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3489 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3490 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3491 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3492 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3493 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3494 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3495 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3496 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3497 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3498 static const wxString wxPyART_PRINT(wxART_PRINT);
3499 static const wxString wxPyART_HELP(wxART_HELP);
3500 static const wxString wxPyART_TIP(wxART_TIP);
3501 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3502 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3503 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3504 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3505 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3506 static const wxString wxPyART_CDROM(wxART_CDROM);
3507 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3508 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3509 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3510 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3511 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3512 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3513 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3514 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3515 static const wxString wxPyART_ERROR(wxART_ERROR);
3516 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3517 static const wxString wxPyART_WARNING(wxART_WARNING);
3518 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3519 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3520 static const wxString wxPyART_COPY(wxART_COPY);
3521 static const wxString wxPyART_CUT(wxART_CUT);
3522 static const wxString wxPyART_PASTE(wxART_PASTE);
3523 static const wxString wxPyART_DELETE(wxART_DELETE);
3524 static const wxString wxPyART_NEW(wxART_NEW);
3525 static const wxString wxPyART_UNDO(wxART_UNDO);
3526 static const wxString wxPyART_REDO(wxART_REDO);
3527 static const wxString wxPyART_QUIT(wxART_QUIT);
3528 static const wxString wxPyART_FIND(wxART_FIND);
3529 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3530 // Python aware wxArtProvider
3531 class wxPyArtProvider : public wxArtProvider {
3532 public:
3533
3534 virtual wxBitmap CreateBitmap(const wxArtID& id,
3535 const wxArtClient& client,
3536 const wxSize& size) {
3537 wxBitmap rval = wxNullBitmap;
3538 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3539 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3540 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3541 PyObject* ro;
3542 wxBitmap* ptr;
3543 PyObject* s1, *s2;
3544 s1 = wx2PyString(id);
3545 s2 = wx2PyString(client);
3546 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3547 Py_DECREF(so);
3548 Py_DECREF(s1);
3549 Py_DECREF(s2);
3550 if (ro) {
3551 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3552 rval = *ptr;
3553 Py_DECREF(ro);
3554 }
3555 }
3556 wxPyEndBlockThreads(blocked);
3557 return rval;
3558 }
3559
3560 virtual wxIconBundle CreateIconBundle(const wxArtID& id,
3561 const wxArtClient& client)
3562 {
3563 wxIconBundle rval = wxNullIconBundle;
3564 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3565 if ((wxPyCBH_findCallback(m_myInst, "CreateIconBundle"))) {
3566 PyObject* ro;
3567 wxIconBundle* ptr;
3568 PyObject* s1, *s2;
3569 s1 = wx2PyString(id);
3570 s2 = wx2PyString(client);
3571 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OO)", s1, s2));
3572 Py_DECREF(s1);
3573 Py_DECREF(s2);
3574 if (ro) {
3575 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxIconBundle")))
3576 rval = *ptr;
3577 Py_DECREF(ro);
3578 }
3579 }
3580 wxPyEndBlockThreads(blocked);
3581 return rval;
3582 }
3583
3584 PYPRIVATE;
3585 };
3586
3587 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3588
3589
3590
3591 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3592 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3593 PyObject* ret = PyTuple_New(3);
3594 if (ret) {
3595 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3596 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3597 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3598 }
3599 wxPyEndBlockThreads(blocked);
3600 return ret;
3601 }
3602
3603 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3604 bool cont;
3605 long index = 0;
3606 wxString value;
3607
3608 cont = self->GetFirstGroup(value, index);
3609 return __EnumerationHelper(cont, value, index);
3610 }
3611 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3612 bool cont;
3613 wxString value;
3614
3615 cont = self->GetNextGroup(value, index);
3616 return __EnumerationHelper(cont, value, index);
3617 }
3618 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3619 bool cont;
3620 long index = 0;
3621 wxString value;
3622
3623 cont = self->GetFirstEntry(value, index);
3624 return __EnumerationHelper(cont, value, index);
3625 }
3626 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3627 bool cont;
3628 wxString value;
3629
3630 cont = self->GetNextEntry(value, index);
3631 return __EnumerationHelper(cont, value, index);
3632 }
3633 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3634 long rv;
3635 self->Read(key, &rv, defaultVal);
3636 return rv;
3637 }
3638
3639 SWIGINTERN int
3640 SWIG_AsVal_double (PyObject *obj, double* val)
3641 {
3642 if (PyNumber_Check(obj)) {
3643 if (val) *val = PyFloat_AsDouble(obj);
3644 return SWIG_OK;
3645 }
3646 return SWIG_TypeError;
3647 }
3648
3649 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3650 double rv;
3651 self->Read(key, &rv, defaultVal);
3652 return rv;
3653 }
3654
3655 #define SWIG_From_double PyFloat_FromDouble
3656
3657 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3658 bool rv;
3659 self->Read(key, &rv, defaultVal);
3660 return rv;
3661 }
3662
3663 #include <wx/datetime.h>
3664
3665 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3666 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3667
3668 #define LOCAL_TZ wxDateTime::Local
3669
3670 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3671 wxString am;
3672 wxString pm;
3673 wxDateTime::GetAmPmStrings(&am, &pm);
3674 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3675 PyObject* tup = PyTuple_New(2);
3676 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3677 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3678 wxPyEndBlockThreads(blocked);
3679 return tup;
3680 }
3681
3682 SWIGINTERNINLINE PyObject *
3683 SWIG_From_unsigned_SS_int (unsigned int value)
3684 {
3685 return SWIG_From_unsigned_SS_long (value);
3686 }
3687
3688 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3689 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3690 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3691 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3692 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3693 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3694 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3695 return (*self < *other);
3696 }
3697 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3698 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3699 return (*self <= *other);
3700 }
3701 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3702 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3703 return (*self > *other);
3704 }
3705 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3706 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3707 return (*self >= *other);
3708 }
3709 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3710 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3711 return (*self == *other);
3712 }
3713 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3714 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3715 return (*self != *other);
3716 }
3717 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3718 const wxChar* rv;
3719 const wxChar* _date = date;
3720 rv = self->ParseRfc822Date(_date);
3721 if (rv == NULL) return -1;
3722 return rv - _date;
3723 }
3724 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3725 const wxChar* rv;
3726 const wxChar* _date = date;
3727 rv = self->ParseFormat(_date, format, dateDef);
3728 if (rv == NULL) return -1;
3729 return rv - _date;
3730 }
3731 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3732 const wxChar* rv;
3733 const wxChar* _datetime = datetime;
3734 rv = self->ParseDateTime(_datetime);
3735 if (rv == NULL) return -1;
3736 return rv - _datetime;
3737 }
3738 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3739 const wxChar* rv;
3740 const wxChar* _date = date;
3741 rv = self->ParseDate(_date);
3742 if (rv == NULL) return -1;
3743 return rv - _date;
3744 }
3745 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3746 const wxChar* rv;
3747 const wxChar* _time = time;
3748 rv = self->ParseTime(_time);
3749 if (rv == NULL) return -1;
3750 return rv - _time;
3751 }
3752 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3753 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3754 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3755 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3756 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3757 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3758 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3759 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3760 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3761 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3762 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3763 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3764 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3765 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3766 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3767 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3768
3769 #include <wx/dataobj.h>
3770
3771 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3772 size_t count = self->GetFormatCount(dir);
3773 wxDataFormat* formats = new wxDataFormat[count];
3774 self->GetAllFormats(formats, dir);
3775
3776 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3777 PyObject* list = PyList_New(count);
3778 for (size_t i=0; i<count; i++) {
3779 wxDataFormat* format = new wxDataFormat(formats[i]);
3780 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3781 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3782 }
3783 wxPyEndBlockThreads(blocked);
3784 delete [] formats;
3785 return list;
3786 }
3787 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3788 PyObject* rval = NULL;
3789 size_t size = self->GetDataSize(format);
3790 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3791 if (size) {
3792 char* buf = new char[size];
3793 if (self->GetDataHere(format, buf))
3794 rval = PyString_FromStringAndSize(buf, size);
3795 delete [] buf;
3796 }
3797 if (! rval) {
3798 rval = Py_None;
3799 Py_INCREF(rval);
3800 }
3801 wxPyEndBlockThreads(blocked);
3802 return rval;
3803 }
3804 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3805 bool rval;
3806 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3807 if (PyString_Check(data)) {
3808 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3809 }
3810 else {
3811 // raise a TypeError if not a string
3812 PyErr_SetString(PyExc_TypeError, "String expected.");
3813 rval = false;
3814 }
3815 wxPyEndBlockThreads(blocked);
3816 return rval;
3817 }
3818 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3819 PyObject* rval = NULL;
3820 size_t size = self->GetDataSize();
3821 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3822 if (size) {
3823 char* buf = new char[size];
3824 if (self->GetDataHere(buf))
3825 rval = PyString_FromStringAndSize(buf, size);
3826 delete [] buf;
3827 }
3828 if (! rval) {
3829 rval = Py_None;
3830 Py_INCREF(rval);
3831 }
3832 wxPyEndBlockThreads(blocked);
3833 return rval;
3834 }
3835 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3836 bool rval;
3837 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3838 if (PyString_Check(data)) {
3839 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3840 }
3841 else {
3842 // raise a TypeError if not a string
3843 PyErr_SetString(PyExc_TypeError, "String expected.");
3844 rval = false;
3845 }
3846 wxPyEndBlockThreads(blocked);
3847 return rval;
3848 }
3849 // Create a new class for wxPython to use
3850 class wxPyDataObjectSimple : public wxDataObjectSimple {
3851 public:
3852 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3853 : wxDataObjectSimple(format) {}
3854
3855 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3856 bool GetDataHere(void *buf) const;
3857 bool SetData(size_t len, const void *buf);
3858 PYPRIVATE;
3859 };
3860
3861 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3862
3863 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3864 // We need to get the data for this object and write it to buf. I think
3865 // the best way to do this for wxPython is to have the Python method
3866 // return either a string or None and then act appropriately with the
3867 // C++ version.
3868
3869 bool rval = false;
3870 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3871 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3872 PyObject* ro;
3873 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3874 if (ro) {
3875 rval = (ro != Py_None && PyString_Check(ro));
3876 if (rval)
3877 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3878 Py_DECREF(ro);
3879 }
3880 }
3881 wxPyEndBlockThreads(blocked);
3882 return rval;
3883 }
3884
3885 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3886 // For this one we simply need to make a string from buf and len
3887 // and send it to the Python method.
3888 bool rval = false;
3889 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3890 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3891 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3892 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3893 Py_DECREF(data);
3894 }
3895 wxPyEndBlockThreads(blocked);
3896 return rval;
3897 }
3898
3899 // Create a new class for wxPython to use
3900 class wxPyTextDataObject : public wxTextDataObject {
3901 public:
3902 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3903 : wxTextDataObject(text) {}
3904
3905 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3906 DEC_PYCALLBACK_STRING__const(GetText);
3907 DEC_PYCALLBACK__STRING(SetText);
3908 PYPRIVATE;
3909 };
3910
3911 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3912 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3913 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3914
3915
3916 // Create a new class for wxPython to use
3917 class wxPyBitmapDataObject : public wxBitmapDataObject {
3918 public:
3919 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3920 : wxBitmapDataObject(bitmap) {}
3921
3922 wxBitmap GetBitmap() const;
3923 void SetBitmap(const wxBitmap& bitmap);
3924 PYPRIVATE;
3925 };
3926
3927 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3928 wxBitmap* rval = &wxNullBitmap;
3929 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3930 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3931 PyObject* ro;
3932 wxBitmap* ptr;
3933 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3934 if (ro) {
3935 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3936 rval = ptr;
3937 Py_DECREF(ro);
3938 }
3939 }
3940 wxPyEndBlockThreads(blocked);
3941 return *rval;
3942 }
3943
3944 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3945 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3946 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3947 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3948 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3949 Py_DECREF(bo);
3950 }
3951 wxPyEndBlockThreads(blocked);
3952 }
3953
3954 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3955 return new wxCustomDataObject(wxDataFormat(formatName));
3956 }
3957 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3958 bool rval;
3959 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3960 if (PyString_Check(data)) {
3961 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3962 }
3963 else {
3964 // raise a TypeError if not a string
3965 PyErr_SetString(PyExc_TypeError, "String expected.");
3966 rval = false;
3967 }
3968 wxPyEndBlockThreads(blocked);
3969 return rval;
3970 }
3971 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3972 PyObject* obj;
3973 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3974 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3975 wxPyEndBlockThreads(blocked);
3976 return obj;
3977 }
3978
3979 class wxMetafileDataObject : public wxDataObjectSimple
3980 {
3981 public:
3982 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3983 };
3984
3985
3986 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3987
3988
3989 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3990 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3991 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3992 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3993 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3994
3995
3996 class wxPyTextDropTarget : public wxTextDropTarget {
3997 public:
3998 wxPyTextDropTarget() {}
3999
4000 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
4001
4002 DEC_PYCALLBACK__(OnLeave);
4003 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
4004 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
4005 DEC_PYCALLBACK_DR_2WXCDR(OnData);
4006 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
4007
4008 PYPRIVATE;
4009 };
4010
4011 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
4012 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
4013 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
4014 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
4015 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
4016 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
4017
4018
4019
4020 class wxPyFileDropTarget : public wxFileDropTarget {
4021 public:
4022 wxPyFileDropTarget() {}
4023
4024 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
4025
4026 DEC_PYCALLBACK__(OnLeave);
4027 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
4028 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
4029 DEC_PYCALLBACK_DR_2WXCDR(OnData);
4030 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
4031
4032 PYPRIVATE;
4033 };
4034
4035 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
4036 const wxArrayString& filenames) {
4037 bool rval = false;
4038 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4039 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
4040 PyObject* list = wxArrayString2PyList_helper(filenames);
4041 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
4042 Py_DECREF(list);
4043 }
4044 wxPyEndBlockThreads(blocked);
4045 return rval;
4046 }
4047
4048
4049
4050 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4051 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4052 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4053 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4054 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4055
4056
4057
4058
4059 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4060
4061 #include <wx/display.h>
4062 #include <wx/vidmode.h>
4063
4064 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4065 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4066
4067 #if !wxUSE_DISPLAY
4068 const wxVideoMode wxDefaultVideoMode;
4069 #endif
4070
4071 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4072 #if wxUSE_DISPLAY
4073 PyObject* pyList = NULL;
4074 wxArrayVideoModes arr = self->GetModes(mode);
4075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4076 pyList = PyList_New(0);
4077 for (size_t i=0; i < arr.GetCount(); i++)
4078 {
4079 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4080 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4081 PyList_Append(pyList, pyObj);
4082 Py_DECREF(pyObj);
4083 }
4084 wxPyEndBlockThreads(blocked);
4085 return pyList;
4086 #else
4087 wxPyRaiseNotImplemented();
4088 return NULL;
4089 #endif
4090 }
4091 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4092 #if wxUSE_DISPLAY
4093 return self->GetCurrentMode();
4094 #else
4095 wxPyRaiseNotImplemented();
4096 return wxDefaultVideoMode;
4097 #endif
4098 }
4099 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4100 #if wxUSE_DISPLAY
4101 return self->ChangeMode(mode);
4102 #else
4103 wxPyRaiseNotImplemented();
4104 return false;
4105 #endif
4106 }
4107 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4108 #if wxUSE_DISPLAY
4109 self->ResetMode();
4110 #else
4111 wxPyRaiseNotImplemented();
4112 #endif
4113 }
4114
4115 #include <wx/stdpaths.h>
4116
4117 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4118 return (wxStandardPaths*) &wxStandardPaths::Get();
4119 }
4120
4121 #ifndef wxHAS_POWER_EVENTS
4122 // Dummy class and other definitions for platforms that don't have them
4123
4124 // See wxPython_int.h for wxPowerEvent
4125
4126 enum {
4127 wxEVT_POWER_SUSPENDING,
4128 wxEVT_POWER_SUSPENDED,
4129 wxEVT_POWER_SUSPEND_CANCEL,
4130 wxEVT_POWER_RESUME,
4131 };
4132
4133 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4134 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4135
4136 #endif
4137
4138
4139 #include <wx/aboutdlg.h>
4140
4141 #ifdef __cplusplus
4142 extern "C" {
4143 #endif
4144 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4145 PyObject *resultobj = 0;
4146 wxSystemColour arg1 ;
4147 wxColour result;
4148 int val1 ;
4149 int ecode1 = 0 ;
4150 PyObject * obj0 = 0 ;
4151 char * kwnames[] = {
4152 (char *) "index", NULL
4153 };
4154
4155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4156 ecode1 = SWIG_AsVal_int(obj0, &val1);
4157 if (!SWIG_IsOK(ecode1)) {
4158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4159 }
4160 arg1 = static_cast< wxSystemColour >(val1);
4161 {
4162 if (!wxPyCheckForApp()) SWIG_fail;
4163 PyThreadState* __tstate = wxPyBeginAllowThreads();
4164 result = wxSystemSettings::GetColour(arg1);
4165 wxPyEndAllowThreads(__tstate);
4166 if (PyErr_Occurred()) SWIG_fail;
4167 }
4168 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4169 return resultobj;
4170 fail:
4171 return NULL;
4172 }
4173
4174
4175 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4176 PyObject *resultobj = 0;
4177 wxSystemFont arg1 ;
4178 wxFont result;
4179 int val1 ;
4180 int ecode1 = 0 ;
4181 PyObject * obj0 = 0 ;
4182 char * kwnames[] = {
4183 (char *) "index", NULL
4184 };
4185
4186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4187 ecode1 = SWIG_AsVal_int(obj0, &val1);
4188 if (!SWIG_IsOK(ecode1)) {
4189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4190 }
4191 arg1 = static_cast< wxSystemFont >(val1);
4192 {
4193 if (!wxPyCheckForApp()) SWIG_fail;
4194 PyThreadState* __tstate = wxPyBeginAllowThreads();
4195 result = wxSystemSettings::GetFont(arg1);
4196 wxPyEndAllowThreads(__tstate);
4197 if (PyErr_Occurred()) SWIG_fail;
4198 }
4199 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4200 return resultobj;
4201 fail:
4202 return NULL;
4203 }
4204
4205
4206 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4207 PyObject *resultobj = 0;
4208 wxSystemMetric arg1 ;
4209 wxWindow *arg2 = (wxWindow *) NULL ;
4210 int result;
4211 int val1 ;
4212 int ecode1 = 0 ;
4213 void *argp2 = 0 ;
4214 int res2 = 0 ;
4215 PyObject * obj0 = 0 ;
4216 PyObject * obj1 = 0 ;
4217 char * kwnames[] = {
4218 (char *) "index",(char *) "win", NULL
4219 };
4220
4221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4222 ecode1 = SWIG_AsVal_int(obj0, &val1);
4223 if (!SWIG_IsOK(ecode1)) {
4224 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4225 }
4226 arg1 = static_cast< wxSystemMetric >(val1);
4227 if (obj1) {
4228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4229 if (!SWIG_IsOK(res2)) {
4230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4231 }
4232 arg2 = reinterpret_cast< wxWindow * >(argp2);
4233 }
4234 {
4235 if (!wxPyCheckForApp()) SWIG_fail;
4236 PyThreadState* __tstate = wxPyBeginAllowThreads();
4237 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4238 wxPyEndAllowThreads(__tstate);
4239 if (PyErr_Occurred()) SWIG_fail;
4240 }
4241 resultobj = SWIG_From_int(static_cast< int >(result));
4242 return resultobj;
4243 fail:
4244 return NULL;
4245 }
4246
4247
4248 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4249 PyObject *resultobj = 0;
4250 wxSystemFeature arg1 ;
4251 bool result;
4252 int val1 ;
4253 int ecode1 = 0 ;
4254 PyObject * obj0 = 0 ;
4255 char * kwnames[] = {
4256 (char *) "index", NULL
4257 };
4258
4259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4260 ecode1 = SWIG_AsVal_int(obj0, &val1);
4261 if (!SWIG_IsOK(ecode1)) {
4262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4263 }
4264 arg1 = static_cast< wxSystemFeature >(val1);
4265 {
4266 if (!wxPyCheckForApp()) SWIG_fail;
4267 PyThreadState* __tstate = wxPyBeginAllowThreads();
4268 result = (bool)wxSystemSettings::HasFeature(arg1);
4269 wxPyEndAllowThreads(__tstate);
4270 if (PyErr_Occurred()) SWIG_fail;
4271 }
4272 {
4273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4274 }
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4282 PyObject *resultobj = 0;
4283 wxSystemScreenType result;
4284
4285 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4286 {
4287 if (!wxPyCheckForApp()) SWIG_fail;
4288 PyThreadState* __tstate = wxPyBeginAllowThreads();
4289 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4290 wxPyEndAllowThreads(__tstate);
4291 if (PyErr_Occurred()) SWIG_fail;
4292 }
4293 resultobj = SWIG_From_int(static_cast< int >(result));
4294 return resultobj;
4295 fail:
4296 return NULL;
4297 }
4298
4299
4300 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4301 PyObject *resultobj = 0;
4302 wxSystemScreenType arg1 ;
4303 int val1 ;
4304 int ecode1 = 0 ;
4305 PyObject * obj0 = 0 ;
4306 char * kwnames[] = {
4307 (char *) "screen", NULL
4308 };
4309
4310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4311 ecode1 = SWIG_AsVal_int(obj0, &val1);
4312 if (!SWIG_IsOK(ecode1)) {
4313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4314 }
4315 arg1 = static_cast< wxSystemScreenType >(val1);
4316 {
4317 if (!wxPyCheckForApp()) SWIG_fail;
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 wxSystemSettings::SetScreenType(arg1);
4320 wxPyEndAllowThreads(__tstate);
4321 if (PyErr_Occurred()) SWIG_fail;
4322 }
4323 resultobj = SWIG_Py_Void();
4324 return resultobj;
4325 fail:
4326 return NULL;
4327 }
4328
4329
4330 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4331 PyObject *obj;
4332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4333 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4334 return SWIG_Py_Void();
4335 }
4336
4337 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4338 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4339 return 1;
4340 }
4341
4342
4343 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4344 PyObject *pyobj = 0;
4345
4346 {
4347 #if wxUSE_UNICODE
4348 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4349 #else
4350 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4351 #endif
4352 }
4353 return pyobj;
4354 }
4355
4356
4357 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4358 PyObject *resultobj = 0;
4359 wxSystemOptions *result = 0 ;
4360
4361 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4362 {
4363 PyThreadState* __tstate = wxPyBeginAllowThreads();
4364 result = (wxSystemOptions *)new wxSystemOptions();
4365 wxPyEndAllowThreads(__tstate);
4366 if (PyErr_Occurred()) SWIG_fail;
4367 }
4368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4369 return resultobj;
4370 fail:
4371 return NULL;
4372 }
4373
4374
4375 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4376 PyObject *resultobj = 0;
4377 wxString *arg1 = 0 ;
4378 wxString *arg2 = 0 ;
4379 bool temp1 = false ;
4380 bool temp2 = false ;
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_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4388 {
4389 arg1 = wxString_in_helper(obj0);
4390 if (arg1 == NULL) SWIG_fail;
4391 temp1 = true;
4392 }
4393 {
4394 arg2 = wxString_in_helper(obj1);
4395 if (arg2 == NULL) SWIG_fail;
4396 temp2 = true;
4397 }
4398 {
4399 PyThreadState* __tstate = wxPyBeginAllowThreads();
4400 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*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 {
4410 if (temp2)
4411 delete arg2;
4412 }
4413 return resultobj;
4414 fail:
4415 {
4416 if (temp1)
4417 delete arg1;
4418 }
4419 {
4420 if (temp2)
4421 delete arg2;
4422 }
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj = 0;
4429 wxString *arg1 = 0 ;
4430 int arg2 ;
4431 bool temp1 = false ;
4432 int val2 ;
4433 int ecode2 = 0 ;
4434 PyObject * obj0 = 0 ;
4435 PyObject * obj1 = 0 ;
4436 char * kwnames[] = {
4437 (char *) "name",(char *) "value", NULL
4438 };
4439
4440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4441 {
4442 arg1 = wxString_in_helper(obj0);
4443 if (arg1 == NULL) SWIG_fail;
4444 temp1 = true;
4445 }
4446 ecode2 = SWIG_AsVal_int(obj1, &val2);
4447 if (!SWIG_IsOK(ecode2)) {
4448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4449 }
4450 arg2 = static_cast< int >(val2);
4451 {
4452 PyThreadState* __tstate = wxPyBeginAllowThreads();
4453 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4454 wxPyEndAllowThreads(__tstate);
4455 if (PyErr_Occurred()) SWIG_fail;
4456 }
4457 resultobj = SWIG_Py_Void();
4458 {
4459 if (temp1)
4460 delete arg1;
4461 }
4462 return resultobj;
4463 fail:
4464 {
4465 if (temp1)
4466 delete arg1;
4467 }
4468 return NULL;
4469 }
4470
4471
4472 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4473 PyObject *resultobj = 0;
4474 wxString *arg1 = 0 ;
4475 wxString result;
4476 bool temp1 = false ;
4477 PyObject * obj0 = 0 ;
4478 char * kwnames[] = {
4479 (char *) "name", NULL
4480 };
4481
4482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4483 {
4484 arg1 = wxString_in_helper(obj0);
4485 if (arg1 == NULL) SWIG_fail;
4486 temp1 = true;
4487 }
4488 {
4489 PyThreadState* __tstate = wxPyBeginAllowThreads();
4490 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4491 wxPyEndAllowThreads(__tstate);
4492 if (PyErr_Occurred()) SWIG_fail;
4493 }
4494 {
4495 #if wxUSE_UNICODE
4496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4497 #else
4498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4499 #endif
4500 }
4501 {
4502 if (temp1)
4503 delete arg1;
4504 }
4505 return resultobj;
4506 fail:
4507 {
4508 if (temp1)
4509 delete arg1;
4510 }
4511 return NULL;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4516 PyObject *resultobj = 0;
4517 wxString *arg1 = 0 ;
4518 int result;
4519 bool temp1 = false ;
4520 PyObject * obj0 = 0 ;
4521 char * kwnames[] = {
4522 (char *) "name", NULL
4523 };
4524
4525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4526 {
4527 arg1 = wxString_in_helper(obj0);
4528 if (arg1 == NULL) SWIG_fail;
4529 temp1 = true;
4530 }
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 resultobj = SWIG_From_int(static_cast< int >(result));
4538 {
4539 if (temp1)
4540 delete arg1;
4541 }
4542 return resultobj;
4543 fail:
4544 {
4545 if (temp1)
4546 delete arg1;
4547 }
4548 return NULL;
4549 }
4550
4551
4552 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4553 PyObject *resultobj = 0;
4554 wxString *arg1 = 0 ;
4555 bool result;
4556 bool temp1 = false ;
4557 PyObject * obj0 = 0 ;
4558 char * kwnames[] = {
4559 (char *) "name", NULL
4560 };
4561
4562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4563 {
4564 arg1 = wxString_in_helper(obj0);
4565 if (arg1 == NULL) SWIG_fail;
4566 temp1 = true;
4567 }
4568 {
4569 PyThreadState* __tstate = wxPyBeginAllowThreads();
4570 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4571 wxPyEndAllowThreads(__tstate);
4572 if (PyErr_Occurred()) SWIG_fail;
4573 }
4574 {
4575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4576 }
4577 {
4578 if (temp1)
4579 delete arg1;
4580 }
4581 return resultobj;
4582 fail:
4583 {
4584 if (temp1)
4585 delete arg1;
4586 }
4587 return NULL;
4588 }
4589
4590
4591 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4592 PyObject *resultobj = 0;
4593 wxString *arg1 = 0 ;
4594 bool result;
4595 bool temp1 = false ;
4596 PyObject * obj0 = 0 ;
4597 char * kwnames[] = {
4598 (char *) "name", NULL
4599 };
4600
4601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4602 {
4603 arg1 = wxString_in_helper(obj0);
4604 if (arg1 == NULL) SWIG_fail;
4605 temp1 = true;
4606 }
4607 {
4608 PyThreadState* __tstate = wxPyBeginAllowThreads();
4609 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4610 wxPyEndAllowThreads(__tstate);
4611 if (PyErr_Occurred()) SWIG_fail;
4612 }
4613 {
4614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4615 }
4616 {
4617 if (temp1)
4618 delete arg1;
4619 }
4620 return resultobj;
4621 fail:
4622 {
4623 if (temp1)
4624 delete arg1;
4625 }
4626 return NULL;
4627 }
4628
4629
4630 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631 PyObject *obj;
4632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4633 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4634 return SWIG_Py_Void();
4635 }
4636
4637 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4638 return SWIG_Python_InitShadowInstance(args);
4639 }
4640
4641 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4642 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4643 return 1;
4644 }
4645
4646
4647 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4648 PyObject *pyobj = 0;
4649
4650 {
4651 #if wxUSE_UNICODE
4652 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4653 #else
4654 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4655 #endif
4656 }
4657 return pyobj;
4658 }
4659
4660
4661 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4662 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4663 return 1;
4664 }
4665
4666
4667 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4668 PyObject *pyobj = 0;
4669
4670 {
4671 #if wxUSE_UNICODE
4672 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4673 #else
4674 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4675 #endif
4676 }
4677 return pyobj;
4678 }
4679
4680
4681 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4682 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4683 return 1;
4684 }
4685
4686
4687 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4688 PyObject *pyobj = 0;
4689
4690 {
4691 #if wxUSE_UNICODE
4692 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4693 #else
4694 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4695 #endif
4696 }
4697 return pyobj;
4698 }
4699
4700
4701 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4702 PyObject *resultobj = 0;
4703 long result;
4704
4705 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4706 {
4707 PyThreadState* __tstate = wxPyBeginAllowThreads();
4708 result = (long)wxNewId();
4709 wxPyEndAllowThreads(__tstate);
4710 if (PyErr_Occurred()) SWIG_fail;
4711 }
4712 resultobj = SWIG_From_long(static_cast< long >(result));
4713 return resultobj;
4714 fail:
4715 return NULL;
4716 }
4717
4718
4719 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4720 PyObject *resultobj = 0;
4721 long arg1 ;
4722 long val1 ;
4723 int ecode1 = 0 ;
4724 PyObject * obj0 = 0 ;
4725 char * kwnames[] = {
4726 (char *) "id", NULL
4727 };
4728
4729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4730 ecode1 = SWIG_AsVal_long(obj0, &val1);
4731 if (!SWIG_IsOK(ecode1)) {
4732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4733 }
4734 arg1 = static_cast< long >(val1);
4735 {
4736 PyThreadState* __tstate = wxPyBeginAllowThreads();
4737 wxRegisterId(arg1);
4738 wxPyEndAllowThreads(__tstate);
4739 if (PyErr_Occurred()) SWIG_fail;
4740 }
4741 resultobj = SWIG_Py_Void();
4742 return resultobj;
4743 fail:
4744 return NULL;
4745 }
4746
4747
4748 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4749 PyObject *resultobj = 0;
4750 long result;
4751
4752 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4753 {
4754 PyThreadState* __tstate = wxPyBeginAllowThreads();
4755 result = (long)wxGetCurrentId();
4756 wxPyEndAllowThreads(__tstate);
4757 if (PyErr_Occurred()) SWIG_fail;
4758 }
4759 resultobj = SWIG_From_long(static_cast< long >(result));
4760 return resultobj;
4761 fail:
4762 return NULL;
4763 }
4764
4765
4766 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4767 PyObject *resultobj = 0;
4768 int arg1 ;
4769 bool result;
4770 int val1 ;
4771 int ecode1 = 0 ;
4772 PyObject * obj0 = 0 ;
4773 char * kwnames[] = {
4774 (char *) "id", NULL
4775 };
4776
4777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4778 ecode1 = SWIG_AsVal_int(obj0, &val1);
4779 if (!SWIG_IsOK(ecode1)) {
4780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4781 }
4782 arg1 = static_cast< int >(val1);
4783 {
4784 PyThreadState* __tstate = wxPyBeginAllowThreads();
4785 result = (bool)wxIsStockID(arg1);
4786 wxPyEndAllowThreads(__tstate);
4787 if (PyErr_Occurred()) SWIG_fail;
4788 }
4789 {
4790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4791 }
4792 return resultobj;
4793 fail:
4794 return NULL;
4795 }
4796
4797
4798 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4799 PyObject *resultobj = 0;
4800 int arg1 ;
4801 wxString *arg2 = 0 ;
4802 bool result;
4803 int val1 ;
4804 int ecode1 = 0 ;
4805 bool temp2 = false ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 char * kwnames[] = {
4809 (char *) "id",(char *) "label", NULL
4810 };
4811
4812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4813 ecode1 = SWIG_AsVal_int(obj0, &val1);
4814 if (!SWIG_IsOK(ecode1)) {
4815 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4816 }
4817 arg1 = static_cast< int >(val1);
4818 {
4819 arg2 = wxString_in_helper(obj1);
4820 if (arg2 == NULL) SWIG_fail;
4821 temp2 = true;
4822 }
4823 {
4824 PyThreadState* __tstate = wxPyBeginAllowThreads();
4825 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 {
4830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4831 }
4832 {
4833 if (temp2)
4834 delete arg2;
4835 }
4836 return resultobj;
4837 fail:
4838 {
4839 if (temp2)
4840 delete arg2;
4841 }
4842 return NULL;
4843 }
4844
4845
4846 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4847 PyObject *resultobj = 0;
4848 int arg1 ;
4849 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4850 wxString result;
4851 int val1 ;
4852 int ecode1 = 0 ;
4853 long val2 ;
4854 int ecode2 = 0 ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 char * kwnames[] = {
4858 (char *) "id",(char *) "flags", NULL
4859 };
4860
4861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4862 ecode1 = SWIG_AsVal_int(obj0, &val1);
4863 if (!SWIG_IsOK(ecode1)) {
4864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4865 }
4866 arg1 = static_cast< int >(val1);
4867 if (obj1) {
4868 ecode2 = SWIG_AsVal_long(obj1, &val2);
4869 if (!SWIG_IsOK(ecode2)) {
4870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4871 }
4872 arg2 = static_cast< long >(val2);
4873 }
4874 {
4875 PyThreadState* __tstate = wxPyBeginAllowThreads();
4876 result = wxGetStockLabel(arg1,arg2);
4877 wxPyEndAllowThreads(__tstate);
4878 if (PyErr_Occurred()) SWIG_fail;
4879 }
4880 {
4881 #if wxUSE_UNICODE
4882 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4883 #else
4884 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4885 #endif
4886 }
4887 return resultobj;
4888 fail:
4889 return NULL;
4890 }
4891
4892
4893 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4894 PyObject *resultobj = 0;
4895 int arg1 ;
4896 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4897 wxString result;
4898 int val1 ;
4899 int ecode1 = 0 ;
4900 int val2 ;
4901 int ecode2 = 0 ;
4902 PyObject * obj0 = 0 ;
4903 PyObject * obj1 = 0 ;
4904 char * kwnames[] = {
4905 (char *) "id",(char *) "client", NULL
4906 };
4907
4908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4909 ecode1 = SWIG_AsVal_int(obj0, &val1);
4910 if (!SWIG_IsOK(ecode1)) {
4911 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4912 }
4913 arg1 = static_cast< int >(val1);
4914 if (obj1) {
4915 ecode2 = SWIG_AsVal_int(obj1, &val2);
4916 if (!SWIG_IsOK(ecode2)) {
4917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4918 }
4919 arg2 = static_cast< wxStockHelpStringClient >(val2);
4920 }
4921 {
4922 PyThreadState* __tstate = wxPyBeginAllowThreads();
4923 result = wxGetStockHelpString(arg1,arg2);
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 {
4928 #if wxUSE_UNICODE
4929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4930 #else
4931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4932 #endif
4933 }
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4941 PyObject *resultobj = 0;
4942
4943 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4944 {
4945 if (!wxPyCheckForApp()) SWIG_fail;
4946 PyThreadState* __tstate = wxPyBeginAllowThreads();
4947 wxBell();
4948 wxPyEndAllowThreads(__tstate);
4949 if (PyErr_Occurred()) SWIG_fail;
4950 }
4951 resultobj = SWIG_Py_Void();
4952 return resultobj;
4953 fail:
4954 return NULL;
4955 }
4956
4957
4958 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4959 PyObject *resultobj = 0;
4960
4961 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4962 {
4963 if (!wxPyCheckForApp()) SWIG_fail;
4964 PyThreadState* __tstate = wxPyBeginAllowThreads();
4965 wxEndBusyCursor();
4966 wxPyEndAllowThreads(__tstate);
4967 if (PyErr_Occurred()) SWIG_fail;
4968 }
4969 resultobj = SWIG_Py_Void();
4970 return resultobj;
4971 fail:
4972 return NULL;
4973 }
4974
4975
4976 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4977 PyObject *resultobj = 0;
4978 bool result;
4979
4980 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4981 {
4982 PyThreadState* __tstate = wxPyBeginAllowThreads();
4983 result = (bool)wxIsBusy();
4984 wxPyEndAllowThreads(__tstate);
4985 if (PyErr_Occurred()) SWIG_fail;
4986 }
4987 {
4988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4989 }
4990 return resultobj;
4991 fail:
4992 return NULL;
4993 }
4994
4995
4996 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4997 PyObject *resultobj = 0;
4998 wxString result;
4999
5000 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
5001 {
5002 PyThreadState* __tstate = wxPyBeginAllowThreads();
5003 result = wxNow();
5004 wxPyEndAllowThreads(__tstate);
5005 if (PyErr_Occurred()) SWIG_fail;
5006 }
5007 {
5008 #if wxUSE_UNICODE
5009 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5010 #else
5011 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5012 #endif
5013 }
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj = 0;
5022 wxString const &arg1_defvalue = wxPyEmptyString ;
5023 wxString *arg1 = (wxString *) &arg1_defvalue ;
5024 bool result;
5025 bool temp1 = false ;
5026 PyObject * obj0 = 0 ;
5027 char * kwnames[] = {
5028 (char *) "command", NULL
5029 };
5030
5031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5032 if (obj0) {
5033 {
5034 arg1 = wxString_in_helper(obj0);
5035 if (arg1 == NULL) SWIG_fail;
5036 temp1 = true;
5037 }
5038 }
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 result = (bool)wxShell((wxString const &)*arg1);
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 {
5046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5047 }
5048 {
5049 if (temp1)
5050 delete arg1;
5051 }
5052 return resultobj;
5053 fail:
5054 {
5055 if (temp1)
5056 delete arg1;
5057 }
5058 return NULL;
5059 }
5060
5061
5062 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5063 PyObject *resultobj = 0;
5064 int *arg1 = (int *) 0 ;
5065 int *arg2 = (int *) 0 ;
5066 int result;
5067 int temp1 ;
5068 int res1 = SWIG_TMPOBJ ;
5069 int temp2 ;
5070 int res2 = SWIG_TMPOBJ ;
5071
5072 arg1 = &temp1;
5073 arg2 = &temp2;
5074 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5075 {
5076 PyThreadState* __tstate = wxPyBeginAllowThreads();
5077 result = (int)wxGetOsVersion(arg1,arg2);
5078 wxPyEndAllowThreads(__tstate);
5079 if (PyErr_Occurred()) SWIG_fail;
5080 }
5081 resultobj = SWIG_From_int(static_cast< int >(result));
5082 if (SWIG_IsTmpObj(res1)) {
5083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5084 } else {
5085 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5087 }
5088 if (SWIG_IsTmpObj(res2)) {
5089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5090 } else {
5091 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5093 }
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5101 PyObject *resultobj = 0;
5102 wxString result;
5103
5104 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5105 {
5106 PyThreadState* __tstate = wxPyBeginAllowThreads();
5107 result = wxGetOsDescription();
5108 wxPyEndAllowThreads(__tstate);
5109 if (PyErr_Occurred()) SWIG_fail;
5110 }
5111 {
5112 #if wxUSE_UNICODE
5113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5114 #else
5115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5116 #endif
5117 }
5118 return resultobj;
5119 fail:
5120 return NULL;
5121 }
5122
5123
5124 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5125 PyObject *resultobj = 0;
5126 bool result;
5127
5128 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5129 {
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 result = (bool)wxIsPlatformLittleEndian();
5132 wxPyEndAllowThreads(__tstate);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 {
5136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5137 }
5138 return resultobj;
5139 fail:
5140 return NULL;
5141 }
5142
5143
5144 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5145 PyObject *resultobj = 0;
5146 bool result;
5147
5148 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5149 {
5150 PyThreadState* __tstate = wxPyBeginAllowThreads();
5151 result = (bool)wxIsPlatform64Bit();
5152 wxPyEndAllowThreads(__tstate);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 {
5156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5157 }
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5165 PyObject *resultobj = 0;
5166 wxMemorySize result;
5167
5168 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5169 {
5170 PyThreadState* __tstate = wxPyBeginAllowThreads();
5171 result = wxGetFreeMemory();
5172 wxPyEndAllowThreads(__tstate);
5173 if (PyErr_Occurred()) SWIG_fail;
5174 }
5175 {
5176 #if wxUSE_LONGLONG
5177 resultobj = PyLong_FromLongLong((&result)->GetValue());
5178 #else
5179 resultobj = PyInt_FromLong(result);
5180 #endif
5181 }
5182 return resultobj;
5183 fail:
5184 return NULL;
5185 }
5186
5187
5188 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5189 PyObject *resultobj = 0;
5190 wxShutdownFlags arg1 ;
5191 bool result;
5192 int val1 ;
5193 int ecode1 = 0 ;
5194 PyObject * obj0 = 0 ;
5195 char * kwnames[] = {
5196 (char *) "wFlags", NULL
5197 };
5198
5199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5200 ecode1 = SWIG_AsVal_int(obj0, &val1);
5201 if (!SWIG_IsOK(ecode1)) {
5202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5203 }
5204 arg1 = static_cast< wxShutdownFlags >(val1);
5205 {
5206 if (!wxPyCheckForApp()) SWIG_fail;
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 result = (bool)wxShutdown(arg1);
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 {
5213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5214 }
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj = 0;
5223 int arg1 ;
5224 int val1 ;
5225 int ecode1 = 0 ;
5226 PyObject * obj0 = 0 ;
5227 char * kwnames[] = {
5228 (char *) "secs", NULL
5229 };
5230
5231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5232 ecode1 = SWIG_AsVal_int(obj0, &val1);
5233 if (!SWIG_IsOK(ecode1)) {
5234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5235 }
5236 arg1 = static_cast< int >(val1);
5237 {
5238 PyThreadState* __tstate = wxPyBeginAllowThreads();
5239 wxSleep(arg1);
5240 wxPyEndAllowThreads(__tstate);
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 resultobj = SWIG_Py_Void();
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5251 PyObject *resultobj = 0;
5252 unsigned long arg1 ;
5253 unsigned long val1 ;
5254 int ecode1 = 0 ;
5255 PyObject * obj0 = 0 ;
5256 char * kwnames[] = {
5257 (char *) "milliseconds", NULL
5258 };
5259
5260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5261 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5262 if (!SWIG_IsOK(ecode1)) {
5263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5264 }
5265 arg1 = static_cast< unsigned long >(val1);
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 wxMilliSleep(arg1);
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 resultobj = SWIG_Py_Void();
5273 return resultobj;
5274 fail:
5275 return NULL;
5276 }
5277
5278
5279 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5280 PyObject *resultobj = 0;
5281 unsigned long arg1 ;
5282 unsigned long val1 ;
5283 int ecode1 = 0 ;
5284 PyObject * obj0 = 0 ;
5285 char * kwnames[] = {
5286 (char *) "microseconds", NULL
5287 };
5288
5289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5290 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5291 if (!SWIG_IsOK(ecode1)) {
5292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5293 }
5294 arg1 = static_cast< unsigned long >(val1);
5295 {
5296 PyThreadState* __tstate = wxPyBeginAllowThreads();
5297 wxMicroSleep(arg1);
5298 wxPyEndAllowThreads(__tstate);
5299 if (PyErr_Occurred()) SWIG_fail;
5300 }
5301 resultobj = SWIG_Py_Void();
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5309 PyObject *resultobj = 0;
5310 bool arg1 ;
5311 bool val1 ;
5312 int ecode1 = 0 ;
5313 PyObject * obj0 = 0 ;
5314 char * kwnames[] = {
5315 (char *) "enable", NULL
5316 };
5317
5318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5319 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5320 if (!SWIG_IsOK(ecode1)) {
5321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5322 }
5323 arg1 = static_cast< bool >(val1);
5324 {
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 wxEnableTopLevelWindows(arg1);
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 resultobj = SWIG_Py_Void();
5331 return resultobj;
5332 fail:
5333 return NULL;
5334 }
5335
5336
5337 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5338 PyObject *resultobj = 0;
5339 wxString *arg1 = 0 ;
5340 wxString result;
5341 bool temp1 = false ;
5342 PyObject * obj0 = 0 ;
5343 char * kwnames[] = {
5344 (char *) "in", NULL
5345 };
5346
5347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5348 {
5349 arg1 = wxString_in_helper(obj0);
5350 if (arg1 == NULL) SWIG_fail;
5351 temp1 = true;
5352 }
5353 {
5354 PyThreadState* __tstate = wxPyBeginAllowThreads();
5355 result = wxStripMenuCodes((wxString const &)*arg1);
5356 wxPyEndAllowThreads(__tstate);
5357 if (PyErr_Occurred()) SWIG_fail;
5358 }
5359 {
5360 #if wxUSE_UNICODE
5361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5362 #else
5363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5364 #endif
5365 }
5366 {
5367 if (temp1)
5368 delete arg1;
5369 }
5370 return resultobj;
5371 fail:
5372 {
5373 if (temp1)
5374 delete arg1;
5375 }
5376 return NULL;
5377 }
5378
5379
5380 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5381 PyObject *resultobj = 0;
5382 wxString result;
5383
5384 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5385 {
5386 PyThreadState* __tstate = wxPyBeginAllowThreads();
5387 result = wxGetEmailAddress();
5388 wxPyEndAllowThreads(__tstate);
5389 if (PyErr_Occurred()) SWIG_fail;
5390 }
5391 {
5392 #if wxUSE_UNICODE
5393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5394 #else
5395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5396 #endif
5397 }
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5405 PyObject *resultobj = 0;
5406 wxString result;
5407
5408 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = wxGetHostName();
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 {
5416 #if wxUSE_UNICODE
5417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5418 #else
5419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5420 #endif
5421 }
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5429 PyObject *resultobj = 0;
5430 wxString result;
5431
5432 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = wxGetFullHostName();
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 {
5440 #if wxUSE_UNICODE
5441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5442 #else
5443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5444 #endif
5445 }
5446 return resultobj;
5447 fail:
5448 return NULL;
5449 }
5450
5451
5452 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5453 PyObject *resultobj = 0;
5454 wxString result;
5455
5456 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 result = wxGetUserId();
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 {
5464 #if wxUSE_UNICODE
5465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5466 #else
5467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5468 #endif
5469 }
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxString result;
5479
5480 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5481 {
5482 PyThreadState* __tstate = wxPyBeginAllowThreads();
5483 result = wxGetUserName();
5484 wxPyEndAllowThreads(__tstate);
5485 if (PyErr_Occurred()) SWIG_fail;
5486 }
5487 {
5488 #if wxUSE_UNICODE
5489 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5490 #else
5491 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5492 #endif
5493 }
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5501 PyObject *resultobj = 0;
5502 wxString result;
5503
5504 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5505 {
5506 PyThreadState* __tstate = wxPyBeginAllowThreads();
5507 result = wxGetHomeDir();
5508 wxPyEndAllowThreads(__tstate);
5509 if (PyErr_Occurred()) SWIG_fail;
5510 }
5511 {
5512 #if wxUSE_UNICODE
5513 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5514 #else
5515 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5516 #endif
5517 }
5518 return resultobj;
5519 fail:
5520 return NULL;
5521 }
5522
5523
5524 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj = 0;
5526 wxString const &arg1_defvalue = wxPyEmptyString ;
5527 wxString *arg1 = (wxString *) &arg1_defvalue ;
5528 wxString result;
5529 bool temp1 = false ;
5530 PyObject * obj0 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "user", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5536 if (obj0) {
5537 {
5538 arg1 = wxString_in_helper(obj0);
5539 if (arg1 == NULL) SWIG_fail;
5540 temp1 = true;
5541 }
5542 }
5543 {
5544 PyThreadState* __tstate = wxPyBeginAllowThreads();
5545 result = wxGetUserHome((wxString const &)*arg1);
5546 wxPyEndAllowThreads(__tstate);
5547 if (PyErr_Occurred()) SWIG_fail;
5548 }
5549 {
5550 #if wxUSE_UNICODE
5551 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5552 #else
5553 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5554 #endif
5555 }
5556 {
5557 if (temp1)
5558 delete arg1;
5559 }
5560 return resultobj;
5561 fail:
5562 {
5563 if (temp1)
5564 delete arg1;
5565 }
5566 return NULL;
5567 }
5568
5569
5570 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5571 PyObject *resultobj = 0;
5572 unsigned long result;
5573
5574 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5575 {
5576 PyThreadState* __tstate = wxPyBeginAllowThreads();
5577 result = (unsigned long)wxGetProcessId();
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589 PyObject *resultobj = 0;
5590
5591 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5592 {
5593 PyThreadState* __tstate = wxPyBeginAllowThreads();
5594 wxTrap();
5595 wxPyEndAllowThreads(__tstate);
5596 if (PyErr_Occurred()) SWIG_fail;
5597 }
5598 resultobj = SWIG_Py_Void();
5599 return resultobj;
5600 fail:
5601 return NULL;
5602 }
5603
5604
5605 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5606 PyObject *resultobj = 0;
5607 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5608 wxString *arg1 = (wxString *) &arg1_defvalue ;
5609 wxString const &arg2_defvalue = wxPyEmptyString ;
5610 wxString *arg2 = (wxString *) &arg2_defvalue ;
5611 wxString const &arg3_defvalue = wxPyEmptyString ;
5612 wxString *arg3 = (wxString *) &arg3_defvalue ;
5613 wxString const &arg4_defvalue = wxPyEmptyString ;
5614 wxString *arg4 = (wxString *) &arg4_defvalue ;
5615 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5616 wxString *arg5 = (wxString *) &arg5_defvalue ;
5617 int arg6 = (int) 0 ;
5618 wxWindow *arg7 = (wxWindow *) NULL ;
5619 int arg8 = (int) -1 ;
5620 int arg9 = (int) -1 ;
5621 wxString result;
5622 bool temp1 = false ;
5623 bool temp2 = false ;
5624 bool temp3 = false ;
5625 bool temp4 = false ;
5626 bool temp5 = false ;
5627 int val6 ;
5628 int ecode6 = 0 ;
5629 void *argp7 = 0 ;
5630 int res7 = 0 ;
5631 int val8 ;
5632 int ecode8 = 0 ;
5633 int val9 ;
5634 int ecode9 = 0 ;
5635 PyObject * obj0 = 0 ;
5636 PyObject * obj1 = 0 ;
5637 PyObject * obj2 = 0 ;
5638 PyObject * obj3 = 0 ;
5639 PyObject * obj4 = 0 ;
5640 PyObject * obj5 = 0 ;
5641 PyObject * obj6 = 0 ;
5642 PyObject * obj7 = 0 ;
5643 PyObject * obj8 = 0 ;
5644 char * kwnames[] = {
5645 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5646 };
5647
5648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5649 if (obj0) {
5650 {
5651 arg1 = wxString_in_helper(obj0);
5652 if (arg1 == NULL) SWIG_fail;
5653 temp1 = true;
5654 }
5655 }
5656 if (obj1) {
5657 {
5658 arg2 = wxString_in_helper(obj1);
5659 if (arg2 == NULL) SWIG_fail;
5660 temp2 = true;
5661 }
5662 }
5663 if (obj2) {
5664 {
5665 arg3 = wxString_in_helper(obj2);
5666 if (arg3 == NULL) SWIG_fail;
5667 temp3 = true;
5668 }
5669 }
5670 if (obj3) {
5671 {
5672 arg4 = wxString_in_helper(obj3);
5673 if (arg4 == NULL) SWIG_fail;
5674 temp4 = true;
5675 }
5676 }
5677 if (obj4) {
5678 {
5679 arg5 = wxString_in_helper(obj4);
5680 if (arg5 == NULL) SWIG_fail;
5681 temp5 = true;
5682 }
5683 }
5684 if (obj5) {
5685 ecode6 = SWIG_AsVal_int(obj5, &val6);
5686 if (!SWIG_IsOK(ecode6)) {
5687 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5688 }
5689 arg6 = static_cast< int >(val6);
5690 }
5691 if (obj6) {
5692 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5693 if (!SWIG_IsOK(res7)) {
5694 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5695 }
5696 arg7 = reinterpret_cast< wxWindow * >(argp7);
5697 }
5698 if (obj7) {
5699 ecode8 = SWIG_AsVal_int(obj7, &val8);
5700 if (!SWIG_IsOK(ecode8)) {
5701 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5702 }
5703 arg8 = static_cast< int >(val8);
5704 }
5705 if (obj8) {
5706 ecode9 = SWIG_AsVal_int(obj8, &val9);
5707 if (!SWIG_IsOK(ecode9)) {
5708 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5709 }
5710 arg9 = static_cast< int >(val9);
5711 }
5712 {
5713 if (!wxPyCheckForApp()) SWIG_fail;
5714 PyThreadState* __tstate = wxPyBeginAllowThreads();
5715 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5716 wxPyEndAllowThreads(__tstate);
5717 if (PyErr_Occurred()) SWIG_fail;
5718 }
5719 {
5720 #if wxUSE_UNICODE
5721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5722 #else
5723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5724 #endif
5725 }
5726 {
5727 if (temp1)
5728 delete arg1;
5729 }
5730 {
5731 if (temp2)
5732 delete arg2;
5733 }
5734 {
5735 if (temp3)
5736 delete arg3;
5737 }
5738 {
5739 if (temp4)
5740 delete arg4;
5741 }
5742 {
5743 if (temp5)
5744 delete arg5;
5745 }
5746 return resultobj;
5747 fail:
5748 {
5749 if (temp1)
5750 delete arg1;
5751 }
5752 {
5753 if (temp2)
5754 delete arg2;
5755 }
5756 {
5757 if (temp3)
5758 delete arg3;
5759 }
5760 {
5761 if (temp4)
5762 delete arg4;
5763 }
5764 {
5765 if (temp5)
5766 delete arg5;
5767 }
5768 return NULL;
5769 }
5770
5771
5772 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5773 PyObject *resultobj = 0;
5774 wxString *arg1 = 0 ;
5775 wxString *arg2 = 0 ;
5776 wxString const &arg3_defvalue = wxPyEmptyString ;
5777 wxString *arg3 = (wxString *) &arg3_defvalue ;
5778 wxWindow *arg4 = (wxWindow *) NULL ;
5779 wxString result;
5780 bool temp1 = false ;
5781 bool temp2 = false ;
5782 bool temp3 = false ;
5783 void *argp4 = 0 ;
5784 int res4 = 0 ;
5785 PyObject * obj0 = 0 ;
5786 PyObject * obj1 = 0 ;
5787 PyObject * obj2 = 0 ;
5788 PyObject * obj3 = 0 ;
5789 char * kwnames[] = {
5790 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5791 };
5792
5793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5794 {
5795 arg1 = wxString_in_helper(obj0);
5796 if (arg1 == NULL) SWIG_fail;
5797 temp1 = true;
5798 }
5799 {
5800 arg2 = wxString_in_helper(obj1);
5801 if (arg2 == NULL) SWIG_fail;
5802 temp2 = true;
5803 }
5804 if (obj2) {
5805 {
5806 arg3 = wxString_in_helper(obj2);
5807 if (arg3 == NULL) SWIG_fail;
5808 temp3 = true;
5809 }
5810 }
5811 if (obj3) {
5812 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5813 if (!SWIG_IsOK(res4)) {
5814 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5815 }
5816 arg4 = reinterpret_cast< wxWindow * >(argp4);
5817 }
5818 {
5819 if (!wxPyCheckForApp()) SWIG_fail;
5820 PyThreadState* __tstate = wxPyBeginAllowThreads();
5821 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5822 wxPyEndAllowThreads(__tstate);
5823 if (PyErr_Occurred()) SWIG_fail;
5824 }
5825 {
5826 #if wxUSE_UNICODE
5827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5828 #else
5829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5830 #endif
5831 }
5832 {
5833 if (temp1)
5834 delete arg1;
5835 }
5836 {
5837 if (temp2)
5838 delete arg2;
5839 }
5840 {
5841 if (temp3)
5842 delete arg3;
5843 }
5844 return resultobj;
5845 fail:
5846 {
5847 if (temp1)
5848 delete arg1;
5849 }
5850 {
5851 if (temp2)
5852 delete arg2;
5853 }
5854 {
5855 if (temp3)
5856 delete arg3;
5857 }
5858 return NULL;
5859 }
5860
5861
5862 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5863 PyObject *resultobj = 0;
5864 wxString *arg1 = 0 ;
5865 wxString *arg2 = 0 ;
5866 wxString const &arg3_defvalue = wxPyEmptyString ;
5867 wxString *arg3 = (wxString *) &arg3_defvalue ;
5868 wxWindow *arg4 = (wxWindow *) NULL ;
5869 wxString result;
5870 bool temp1 = false ;
5871 bool temp2 = false ;
5872 bool temp3 = false ;
5873 void *argp4 = 0 ;
5874 int res4 = 0 ;
5875 PyObject * obj0 = 0 ;
5876 PyObject * obj1 = 0 ;
5877 PyObject * obj2 = 0 ;
5878 PyObject * obj3 = 0 ;
5879 char * kwnames[] = {
5880 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5881 };
5882
5883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5884 {
5885 arg1 = wxString_in_helper(obj0);
5886 if (arg1 == NULL) SWIG_fail;
5887 temp1 = true;
5888 }
5889 {
5890 arg2 = wxString_in_helper(obj1);
5891 if (arg2 == NULL) SWIG_fail;
5892 temp2 = true;
5893 }
5894 if (obj2) {
5895 {
5896 arg3 = wxString_in_helper(obj2);
5897 if (arg3 == NULL) SWIG_fail;
5898 temp3 = true;
5899 }
5900 }
5901 if (obj3) {
5902 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5903 if (!SWIG_IsOK(res4)) {
5904 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5905 }
5906 arg4 = reinterpret_cast< wxWindow * >(argp4);
5907 }
5908 {
5909 if (!wxPyCheckForApp()) SWIG_fail;
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5912 wxPyEndAllowThreads(__tstate);
5913 if (PyErr_Occurred()) SWIG_fail;
5914 }
5915 {
5916 #if wxUSE_UNICODE
5917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5918 #else
5919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5920 #endif
5921 }
5922 {
5923 if (temp1)
5924 delete arg1;
5925 }
5926 {
5927 if (temp2)
5928 delete arg2;
5929 }
5930 {
5931 if (temp3)
5932 delete arg3;
5933 }
5934 return resultobj;
5935 fail:
5936 {
5937 if (temp1)
5938 delete arg1;
5939 }
5940 {
5941 if (temp2)
5942 delete arg2;
5943 }
5944 {
5945 if (temp3)
5946 delete arg3;
5947 }
5948 return NULL;
5949 }
5950
5951
5952 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5953 PyObject *resultobj = 0;
5954 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5955 wxString *arg1 = (wxString *) &arg1_defvalue ;
5956 wxString const &arg2_defvalue = wxPyEmptyString ;
5957 wxString *arg2 = (wxString *) &arg2_defvalue ;
5958 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5959 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5960 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5961 wxWindow *arg5 = (wxWindow *) NULL ;
5962 wxString result;
5963 bool temp1 = false ;
5964 bool temp2 = false ;
5965 long val3 ;
5966 int ecode3 = 0 ;
5967 wxPoint temp4 ;
5968 void *argp5 = 0 ;
5969 int res5 = 0 ;
5970 PyObject * obj0 = 0 ;
5971 PyObject * obj1 = 0 ;
5972 PyObject * obj2 = 0 ;
5973 PyObject * obj3 = 0 ;
5974 PyObject * obj4 = 0 ;
5975 char * kwnames[] = {
5976 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5977 };
5978
5979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5980 if (obj0) {
5981 {
5982 arg1 = wxString_in_helper(obj0);
5983 if (arg1 == NULL) SWIG_fail;
5984 temp1 = true;
5985 }
5986 }
5987 if (obj1) {
5988 {
5989 arg2 = wxString_in_helper(obj1);
5990 if (arg2 == NULL) SWIG_fail;
5991 temp2 = true;
5992 }
5993 }
5994 if (obj2) {
5995 ecode3 = SWIG_AsVal_long(obj2, &val3);
5996 if (!SWIG_IsOK(ecode3)) {
5997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5998 }
5999 arg3 = static_cast< long >(val3);
6000 }
6001 if (obj3) {
6002 {
6003 arg4 = &temp4;
6004 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6005 }
6006 }
6007 if (obj4) {
6008 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6009 if (!SWIG_IsOK(res5)) {
6010 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6011 }
6012 arg5 = reinterpret_cast< wxWindow * >(argp5);
6013 }
6014 {
6015 if (!wxPyCheckForApp()) SWIG_fail;
6016 PyThreadState* __tstate = wxPyBeginAllowThreads();
6017 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 {
6022 #if wxUSE_UNICODE
6023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6024 #else
6025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6026 #endif
6027 }
6028 {
6029 if (temp1)
6030 delete arg1;
6031 }
6032 {
6033 if (temp2)
6034 delete arg2;
6035 }
6036 return resultobj;
6037 fail:
6038 {
6039 if (temp1)
6040 delete arg1;
6041 }
6042 {
6043 if (temp2)
6044 delete arg2;
6045 }
6046 return NULL;
6047 }
6048
6049
6050 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj = 0;
6052 wxString *arg1 = 0 ;
6053 wxString const &arg2_defvalue = wxPyEmptyString ;
6054 wxString *arg2 = (wxString *) &arg2_defvalue ;
6055 wxString const &arg3_defvalue = wxPyEmptyString ;
6056 wxString *arg3 = (wxString *) &arg3_defvalue ;
6057 wxWindow *arg4 = (wxWindow *) NULL ;
6058 int arg5 = (int) -1 ;
6059 int arg6 = (int) -1 ;
6060 bool arg7 = (bool) true ;
6061 wxString result;
6062 bool temp1 = false ;
6063 bool temp2 = false ;
6064 bool temp3 = false ;
6065 void *argp4 = 0 ;
6066 int res4 = 0 ;
6067 int val5 ;
6068 int ecode5 = 0 ;
6069 int val6 ;
6070 int ecode6 = 0 ;
6071 bool val7 ;
6072 int ecode7 = 0 ;
6073 PyObject * obj0 = 0 ;
6074 PyObject * obj1 = 0 ;
6075 PyObject * obj2 = 0 ;
6076 PyObject * obj3 = 0 ;
6077 PyObject * obj4 = 0 ;
6078 PyObject * obj5 = 0 ;
6079 PyObject * obj6 = 0 ;
6080 char * kwnames[] = {
6081 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6082 };
6083
6084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6085 {
6086 arg1 = wxString_in_helper(obj0);
6087 if (arg1 == NULL) SWIG_fail;
6088 temp1 = true;
6089 }
6090 if (obj1) {
6091 {
6092 arg2 = wxString_in_helper(obj1);
6093 if (arg2 == NULL) SWIG_fail;
6094 temp2 = true;
6095 }
6096 }
6097 if (obj2) {
6098 {
6099 arg3 = wxString_in_helper(obj2);
6100 if (arg3 == NULL) SWIG_fail;
6101 temp3 = true;
6102 }
6103 }
6104 if (obj3) {
6105 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6106 if (!SWIG_IsOK(res4)) {
6107 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6108 }
6109 arg4 = reinterpret_cast< wxWindow * >(argp4);
6110 }
6111 if (obj4) {
6112 ecode5 = SWIG_AsVal_int(obj4, &val5);
6113 if (!SWIG_IsOK(ecode5)) {
6114 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6115 }
6116 arg5 = static_cast< int >(val5);
6117 }
6118 if (obj5) {
6119 ecode6 = SWIG_AsVal_int(obj5, &val6);
6120 if (!SWIG_IsOK(ecode6)) {
6121 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6122 }
6123 arg6 = static_cast< int >(val6);
6124 }
6125 if (obj6) {
6126 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6127 if (!SWIG_IsOK(ecode7)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6129 }
6130 arg7 = static_cast< bool >(val7);
6131 }
6132 {
6133 if (!wxPyCheckForApp()) SWIG_fail;
6134 PyThreadState* __tstate = wxPyBeginAllowThreads();
6135 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 {
6140 #if wxUSE_UNICODE
6141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6142 #else
6143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6144 #endif
6145 }
6146 {
6147 if (temp1)
6148 delete arg1;
6149 }
6150 {
6151 if (temp2)
6152 delete arg2;
6153 }
6154 {
6155 if (temp3)
6156 delete arg3;
6157 }
6158 return resultobj;
6159 fail:
6160 {
6161 if (temp1)
6162 delete arg1;
6163 }
6164 {
6165 if (temp2)
6166 delete arg2;
6167 }
6168 {
6169 if (temp3)
6170 delete arg3;
6171 }
6172 return NULL;
6173 }
6174
6175
6176 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6177 PyObject *resultobj = 0;
6178 wxString *arg1 = 0 ;
6179 wxString const &arg2_defvalue = wxPyEmptyString ;
6180 wxString *arg2 = (wxString *) &arg2_defvalue ;
6181 wxString const &arg3_defvalue = wxPyEmptyString ;
6182 wxString *arg3 = (wxString *) &arg3_defvalue ;
6183 wxWindow *arg4 = (wxWindow *) NULL ;
6184 wxString result;
6185 bool temp1 = false ;
6186 bool temp2 = false ;
6187 bool temp3 = false ;
6188 void *argp4 = 0 ;
6189 int res4 = 0 ;
6190 PyObject * obj0 = 0 ;
6191 PyObject * obj1 = 0 ;
6192 PyObject * obj2 = 0 ;
6193 PyObject * obj3 = 0 ;
6194 char * kwnames[] = {
6195 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6196 };
6197
6198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6199 {
6200 arg1 = wxString_in_helper(obj0);
6201 if (arg1 == NULL) SWIG_fail;
6202 temp1 = true;
6203 }
6204 if (obj1) {
6205 {
6206 arg2 = wxString_in_helper(obj1);
6207 if (arg2 == NULL) SWIG_fail;
6208 temp2 = true;
6209 }
6210 }
6211 if (obj2) {
6212 {
6213 arg3 = wxString_in_helper(obj2);
6214 if (arg3 == NULL) SWIG_fail;
6215 temp3 = true;
6216 }
6217 }
6218 if (obj3) {
6219 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6220 if (!SWIG_IsOK(res4)) {
6221 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6222 }
6223 arg4 = reinterpret_cast< wxWindow * >(argp4);
6224 }
6225 {
6226 if (!wxPyCheckForApp()) SWIG_fail;
6227 PyThreadState* __tstate = wxPyBeginAllowThreads();
6228 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6229 wxPyEndAllowThreads(__tstate);
6230 if (PyErr_Occurred()) SWIG_fail;
6231 }
6232 {
6233 #if wxUSE_UNICODE
6234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6235 #else
6236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6237 #endif
6238 }
6239 {
6240 if (temp1)
6241 delete arg1;
6242 }
6243 {
6244 if (temp2)
6245 delete arg2;
6246 }
6247 {
6248 if (temp3)
6249 delete arg3;
6250 }
6251 return resultobj;
6252 fail:
6253 {
6254 if (temp1)
6255 delete arg1;
6256 }
6257 {
6258 if (temp2)
6259 delete arg2;
6260 }
6261 {
6262 if (temp3)
6263 delete arg3;
6264 }
6265 return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6270 PyObject *resultobj = 0;
6271 wxString *arg1 = 0 ;
6272 wxString *arg2 = 0 ;
6273 int arg3 ;
6274 wxString *arg4 = (wxString *) 0 ;
6275 wxWindow *arg5 = (wxWindow *) NULL ;
6276 int arg6 = (int) -1 ;
6277 int arg7 = (int) -1 ;
6278 bool arg8 = (bool) true ;
6279 int arg9 = (int) 150 ;
6280 int arg10 = (int) 200 ;
6281 wxString result;
6282 bool temp1 = false ;
6283 bool temp2 = false ;
6284 void *argp5 = 0 ;
6285 int res5 = 0 ;
6286 int val6 ;
6287 int ecode6 = 0 ;
6288 int val7 ;
6289 int ecode7 = 0 ;
6290 bool val8 ;
6291 int ecode8 = 0 ;
6292 int val9 ;
6293 int ecode9 = 0 ;
6294 int val10 ;
6295 int ecode10 = 0 ;
6296 PyObject * obj0 = 0 ;
6297 PyObject * obj1 = 0 ;
6298 PyObject * obj2 = 0 ;
6299 PyObject * obj3 = 0 ;
6300 PyObject * obj4 = 0 ;
6301 PyObject * obj5 = 0 ;
6302 PyObject * obj6 = 0 ;
6303 PyObject * obj7 = 0 ;
6304 PyObject * obj8 = 0 ;
6305 char * kwnames[] = {
6306 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6307 };
6308
6309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6310 {
6311 arg1 = wxString_in_helper(obj0);
6312 if (arg1 == NULL) SWIG_fail;
6313 temp1 = true;
6314 }
6315 {
6316 arg2 = wxString_in_helper(obj1);
6317 if (arg2 == NULL) SWIG_fail;
6318 temp2 = true;
6319 }
6320 {
6321 arg3 = PyList_Size(obj2);
6322 arg4 = wxString_LIST_helper(obj2);
6323 if (arg4 == NULL) SWIG_fail;
6324 }
6325 if (obj3) {
6326 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6327 if (!SWIG_IsOK(res5)) {
6328 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6329 }
6330 arg5 = reinterpret_cast< wxWindow * >(argp5);
6331 }
6332 if (obj4) {
6333 ecode6 = SWIG_AsVal_int(obj4, &val6);
6334 if (!SWIG_IsOK(ecode6)) {
6335 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6336 }
6337 arg6 = static_cast< int >(val6);
6338 }
6339 if (obj5) {
6340 ecode7 = SWIG_AsVal_int(obj5, &val7);
6341 if (!SWIG_IsOK(ecode7)) {
6342 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6343 }
6344 arg7 = static_cast< int >(val7);
6345 }
6346 if (obj6) {
6347 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6348 if (!SWIG_IsOK(ecode8)) {
6349 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6350 }
6351 arg8 = static_cast< bool >(val8);
6352 }
6353 if (obj7) {
6354 ecode9 = SWIG_AsVal_int(obj7, &val9);
6355 if (!SWIG_IsOK(ecode9)) {
6356 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6357 }
6358 arg9 = static_cast< int >(val9);
6359 }
6360 if (obj8) {
6361 ecode10 = SWIG_AsVal_int(obj8, &val10);
6362 if (!SWIG_IsOK(ecode10)) {
6363 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6364 }
6365 arg10 = static_cast< int >(val10);
6366 }
6367 {
6368 if (!wxPyCheckForApp()) SWIG_fail;
6369 PyThreadState* __tstate = wxPyBeginAllowThreads();
6370 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6371 wxPyEndAllowThreads(__tstate);
6372 if (PyErr_Occurred()) SWIG_fail;
6373 }
6374 {
6375 #if wxUSE_UNICODE
6376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6377 #else
6378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6379 #endif
6380 }
6381 {
6382 if (temp1)
6383 delete arg1;
6384 }
6385 {
6386 if (temp2)
6387 delete arg2;
6388 }
6389 {
6390 if (arg4) delete [] arg4;
6391 }
6392 return resultobj;
6393 fail:
6394 {
6395 if (temp1)
6396 delete arg1;
6397 }
6398 {
6399 if (temp2)
6400 delete arg2;
6401 }
6402 {
6403 if (arg4) delete [] arg4;
6404 }
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6410 PyObject *resultobj = 0;
6411 wxString *arg1 = 0 ;
6412 wxString *arg2 = 0 ;
6413 int arg3 ;
6414 wxString *arg4 = (wxString *) 0 ;
6415 wxWindow *arg5 = (wxWindow *) NULL ;
6416 int arg6 = (int) -1 ;
6417 int arg7 = (int) -1 ;
6418 bool arg8 = (bool) true ;
6419 int arg9 = (int) 150 ;
6420 int arg10 = (int) 200 ;
6421 int result;
6422 bool temp1 = false ;
6423 bool temp2 = false ;
6424 void *argp5 = 0 ;
6425 int res5 = 0 ;
6426 int val6 ;
6427 int ecode6 = 0 ;
6428 int val7 ;
6429 int ecode7 = 0 ;
6430 bool val8 ;
6431 int ecode8 = 0 ;
6432 int val9 ;
6433 int ecode9 = 0 ;
6434 int val10 ;
6435 int ecode10 = 0 ;
6436 PyObject * obj0 = 0 ;
6437 PyObject * obj1 = 0 ;
6438 PyObject * obj2 = 0 ;
6439 PyObject * obj3 = 0 ;
6440 PyObject * obj4 = 0 ;
6441 PyObject * obj5 = 0 ;
6442 PyObject * obj6 = 0 ;
6443 PyObject * obj7 = 0 ;
6444 PyObject * obj8 = 0 ;
6445 char * kwnames[] = {
6446 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6447 };
6448
6449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6450 {
6451 arg1 = wxString_in_helper(obj0);
6452 if (arg1 == NULL) SWIG_fail;
6453 temp1 = true;
6454 }
6455 {
6456 arg2 = wxString_in_helper(obj1);
6457 if (arg2 == NULL) SWIG_fail;
6458 temp2 = true;
6459 }
6460 {
6461 arg3 = PyList_Size(obj2);
6462 arg4 = wxString_LIST_helper(obj2);
6463 if (arg4 == NULL) SWIG_fail;
6464 }
6465 if (obj3) {
6466 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6467 if (!SWIG_IsOK(res5)) {
6468 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6469 }
6470 arg5 = reinterpret_cast< wxWindow * >(argp5);
6471 }
6472 if (obj4) {
6473 ecode6 = SWIG_AsVal_int(obj4, &val6);
6474 if (!SWIG_IsOK(ecode6)) {
6475 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6476 }
6477 arg6 = static_cast< int >(val6);
6478 }
6479 if (obj5) {
6480 ecode7 = SWIG_AsVal_int(obj5, &val7);
6481 if (!SWIG_IsOK(ecode7)) {
6482 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6483 }
6484 arg7 = static_cast< int >(val7);
6485 }
6486 if (obj6) {
6487 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6488 if (!SWIG_IsOK(ecode8)) {
6489 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6490 }
6491 arg8 = static_cast< bool >(val8);
6492 }
6493 if (obj7) {
6494 ecode9 = SWIG_AsVal_int(obj7, &val9);
6495 if (!SWIG_IsOK(ecode9)) {
6496 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6497 }
6498 arg9 = static_cast< int >(val9);
6499 }
6500 if (obj8) {
6501 ecode10 = SWIG_AsVal_int(obj8, &val10);
6502 if (!SWIG_IsOK(ecode10)) {
6503 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6504 }
6505 arg10 = static_cast< int >(val10);
6506 }
6507 {
6508 if (!wxPyCheckForApp()) SWIG_fail;
6509 PyThreadState* __tstate = wxPyBeginAllowThreads();
6510 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6511 wxPyEndAllowThreads(__tstate);
6512 if (PyErr_Occurred()) SWIG_fail;
6513 }
6514 resultobj = SWIG_From_int(static_cast< int >(result));
6515 {
6516 if (temp1)
6517 delete arg1;
6518 }
6519 {
6520 if (temp2)
6521 delete arg2;
6522 }
6523 {
6524 if (arg4) delete [] arg4;
6525 }
6526 return resultobj;
6527 fail:
6528 {
6529 if (temp1)
6530 delete arg1;
6531 }
6532 {
6533 if (temp2)
6534 delete arg2;
6535 }
6536 {
6537 if (arg4) delete [] arg4;
6538 }
6539 return NULL;
6540 }
6541
6542
6543 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6544 PyObject *resultobj = 0;
6545 wxString *arg1 = 0 ;
6546 wxString const &arg2_defvalue = wxPyEmptyString ;
6547 wxString *arg2 = (wxString *) &arg2_defvalue ;
6548 int arg3 = (int) wxOK|wxCENTRE ;
6549 wxWindow *arg4 = (wxWindow *) NULL ;
6550 int arg5 = (int) -1 ;
6551 int arg6 = (int) -1 ;
6552 int result;
6553 bool temp1 = false ;
6554 bool temp2 = false ;
6555 int val3 ;
6556 int ecode3 = 0 ;
6557 void *argp4 = 0 ;
6558 int res4 = 0 ;
6559 int val5 ;
6560 int ecode5 = 0 ;
6561 int val6 ;
6562 int ecode6 = 0 ;
6563 PyObject * obj0 = 0 ;
6564 PyObject * obj1 = 0 ;
6565 PyObject * obj2 = 0 ;
6566 PyObject * obj3 = 0 ;
6567 PyObject * obj4 = 0 ;
6568 PyObject * obj5 = 0 ;
6569 char * kwnames[] = {
6570 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6571 };
6572
6573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6574 {
6575 arg1 = wxString_in_helper(obj0);
6576 if (arg1 == NULL) SWIG_fail;
6577 temp1 = true;
6578 }
6579 if (obj1) {
6580 {
6581 arg2 = wxString_in_helper(obj1);
6582 if (arg2 == NULL) SWIG_fail;
6583 temp2 = true;
6584 }
6585 }
6586 if (obj2) {
6587 ecode3 = SWIG_AsVal_int(obj2, &val3);
6588 if (!SWIG_IsOK(ecode3)) {
6589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6590 }
6591 arg3 = static_cast< int >(val3);
6592 }
6593 if (obj3) {
6594 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6595 if (!SWIG_IsOK(res4)) {
6596 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6597 }
6598 arg4 = reinterpret_cast< wxWindow * >(argp4);
6599 }
6600 if (obj4) {
6601 ecode5 = SWIG_AsVal_int(obj4, &val5);
6602 if (!SWIG_IsOK(ecode5)) {
6603 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6604 }
6605 arg5 = static_cast< int >(val5);
6606 }
6607 if (obj5) {
6608 ecode6 = SWIG_AsVal_int(obj5, &val6);
6609 if (!SWIG_IsOK(ecode6)) {
6610 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6611 }
6612 arg6 = static_cast< int >(val6);
6613 }
6614 {
6615 if (!wxPyCheckForApp()) SWIG_fail;
6616 PyThreadState* __tstate = wxPyBeginAllowThreads();
6617 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6618 wxPyEndAllowThreads(__tstate);
6619 if (PyErr_Occurred()) SWIG_fail;
6620 }
6621 resultobj = SWIG_From_int(static_cast< int >(result));
6622 {
6623 if (temp1)
6624 delete arg1;
6625 }
6626 {
6627 if (temp2)
6628 delete arg2;
6629 }
6630 return resultobj;
6631 fail:
6632 {
6633 if (temp1)
6634 delete arg1;
6635 }
6636 {
6637 if (temp2)
6638 delete arg2;
6639 }
6640 return NULL;
6641 }
6642
6643
6644 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6645 PyObject *resultobj = 0;
6646 wxString *arg1 = 0 ;
6647 wxString *arg2 = 0 ;
6648 wxString *arg3 = 0 ;
6649 long arg4 ;
6650 long arg5 = (long) 0 ;
6651 long arg6 = (long) 100 ;
6652 wxWindow *arg7 = (wxWindow *) NULL ;
6653 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6654 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6655 long result;
6656 bool temp1 = false ;
6657 bool temp2 = false ;
6658 bool temp3 = false ;
6659 long val4 ;
6660 int ecode4 = 0 ;
6661 long val5 ;
6662 int ecode5 = 0 ;
6663 long val6 ;
6664 int ecode6 = 0 ;
6665 void *argp7 = 0 ;
6666 int res7 = 0 ;
6667 wxPoint temp8 ;
6668 PyObject * obj0 = 0 ;
6669 PyObject * obj1 = 0 ;
6670 PyObject * obj2 = 0 ;
6671 PyObject * obj3 = 0 ;
6672 PyObject * obj4 = 0 ;
6673 PyObject * obj5 = 0 ;
6674 PyObject * obj6 = 0 ;
6675 PyObject * obj7 = 0 ;
6676 char * kwnames[] = {
6677 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6678 };
6679
6680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6681 {
6682 arg1 = wxString_in_helper(obj0);
6683 if (arg1 == NULL) SWIG_fail;
6684 temp1 = true;
6685 }
6686 {
6687 arg2 = wxString_in_helper(obj1);
6688 if (arg2 == NULL) SWIG_fail;
6689 temp2 = true;
6690 }
6691 {
6692 arg3 = wxString_in_helper(obj2);
6693 if (arg3 == NULL) SWIG_fail;
6694 temp3 = true;
6695 }
6696 ecode4 = SWIG_AsVal_long(obj3, &val4);
6697 if (!SWIG_IsOK(ecode4)) {
6698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6699 }
6700 arg4 = static_cast< long >(val4);
6701 if (obj4) {
6702 ecode5 = SWIG_AsVal_long(obj4, &val5);
6703 if (!SWIG_IsOK(ecode5)) {
6704 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6705 }
6706 arg5 = static_cast< long >(val5);
6707 }
6708 if (obj5) {
6709 ecode6 = SWIG_AsVal_long(obj5, &val6);
6710 if (!SWIG_IsOK(ecode6)) {
6711 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6712 }
6713 arg6 = static_cast< long >(val6);
6714 }
6715 if (obj6) {
6716 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6717 if (!SWIG_IsOK(res7)) {
6718 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6719 }
6720 arg7 = reinterpret_cast< wxWindow * >(argp7);
6721 }
6722 if (obj7) {
6723 {
6724 arg8 = &temp8;
6725 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6726 }
6727 }
6728 {
6729 if (!wxPyCheckForApp()) SWIG_fail;
6730 PyThreadState* __tstate = wxPyBeginAllowThreads();
6731 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6732 wxPyEndAllowThreads(__tstate);
6733 if (PyErr_Occurred()) SWIG_fail;
6734 }
6735 resultobj = SWIG_From_long(static_cast< long >(result));
6736 {
6737 if (temp1)
6738 delete arg1;
6739 }
6740 {
6741 if (temp2)
6742 delete arg2;
6743 }
6744 {
6745 if (temp3)
6746 delete arg3;
6747 }
6748 return resultobj;
6749 fail:
6750 {
6751 if (temp1)
6752 delete arg1;
6753 }
6754 {
6755 if (temp2)
6756 delete arg2;
6757 }
6758 {
6759 if (temp3)
6760 delete arg3;
6761 }
6762 return NULL;
6763 }
6764
6765
6766 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6767 PyObject *resultobj = 0;
6768 bool result;
6769
6770 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6771 {
6772 if (!wxPyCheckForApp()) SWIG_fail;
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = (bool)wxColourDisplay();
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 {
6779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6780 }
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6788 PyObject *resultobj = 0;
6789 int result;
6790
6791 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6792 {
6793 if (!wxPyCheckForApp()) SWIG_fail;
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 result = (int)wxDisplayDepth();
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_From_int(static_cast< int >(result));
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6807 PyObject *resultobj = 0;
6808 int result;
6809
6810 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6811 {
6812 if (!wxPyCheckForApp()) SWIG_fail;
6813 PyThreadState* __tstate = wxPyBeginAllowThreads();
6814 result = (int)wxGetDisplayDepth();
6815 wxPyEndAllowThreads(__tstate);
6816 if (PyErr_Occurred()) SWIG_fail;
6817 }
6818 resultobj = SWIG_From_int(static_cast< int >(result));
6819 return resultobj;
6820 fail:
6821 return NULL;
6822 }
6823
6824
6825 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6826 PyObject *resultobj = 0;
6827 int *arg1 = (int *) 0 ;
6828 int *arg2 = (int *) 0 ;
6829 int temp1 ;
6830 int res1 = SWIG_TMPOBJ ;
6831 int temp2 ;
6832 int res2 = SWIG_TMPOBJ ;
6833
6834 arg1 = &temp1;
6835 arg2 = &temp2;
6836 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6837 {
6838 if (!wxPyCheckForApp()) SWIG_fail;
6839 PyThreadState* __tstate = wxPyBeginAllowThreads();
6840 wxDisplaySize(arg1,arg2);
6841 wxPyEndAllowThreads(__tstate);
6842 if (PyErr_Occurred()) SWIG_fail;
6843 }
6844 resultobj = SWIG_Py_Void();
6845 if (SWIG_IsTmpObj(res1)) {
6846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6847 } else {
6848 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6850 }
6851 if (SWIG_IsTmpObj(res2)) {
6852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6853 } else {
6854 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6856 }
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6864 PyObject *resultobj = 0;
6865 wxSize result;
6866
6867 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6868 {
6869 if (!wxPyCheckForApp()) SWIG_fail;
6870 PyThreadState* __tstate = wxPyBeginAllowThreads();
6871 result = wxGetDisplaySize();
6872 wxPyEndAllowThreads(__tstate);
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6883 PyObject *resultobj = 0;
6884 int *arg1 = (int *) 0 ;
6885 int *arg2 = (int *) 0 ;
6886 int temp1 ;
6887 int res1 = SWIG_TMPOBJ ;
6888 int temp2 ;
6889 int res2 = SWIG_TMPOBJ ;
6890
6891 arg1 = &temp1;
6892 arg2 = &temp2;
6893 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6894 {
6895 if (!wxPyCheckForApp()) SWIG_fail;
6896 PyThreadState* __tstate = wxPyBeginAllowThreads();
6897 wxDisplaySizeMM(arg1,arg2);
6898 wxPyEndAllowThreads(__tstate);
6899 if (PyErr_Occurred()) SWIG_fail;
6900 }
6901 resultobj = SWIG_Py_Void();
6902 if (SWIG_IsTmpObj(res1)) {
6903 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6904 } else {
6905 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6906 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6907 }
6908 if (SWIG_IsTmpObj(res2)) {
6909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6910 } else {
6911 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6913 }
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6921 PyObject *resultobj = 0;
6922 wxSize result;
6923
6924 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6925 {
6926 if (!wxPyCheckForApp()) SWIG_fail;
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 result = wxGetDisplaySizeMM();
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6940 PyObject *resultobj = 0;
6941 int *arg1 = (int *) 0 ;
6942 int *arg2 = (int *) 0 ;
6943 int *arg3 = (int *) 0 ;
6944 int *arg4 = (int *) 0 ;
6945 int temp1 ;
6946 int res1 = SWIG_TMPOBJ ;
6947 int temp2 ;
6948 int res2 = SWIG_TMPOBJ ;
6949 int temp3 ;
6950 int res3 = SWIG_TMPOBJ ;
6951 int temp4 ;
6952 int res4 = SWIG_TMPOBJ ;
6953
6954 arg1 = &temp1;
6955 arg2 = &temp2;
6956 arg3 = &temp3;
6957 arg4 = &temp4;
6958 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6959 {
6960 if (!wxPyCheckForApp()) SWIG_fail;
6961 PyThreadState* __tstate = wxPyBeginAllowThreads();
6962 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6963 wxPyEndAllowThreads(__tstate);
6964 if (PyErr_Occurred()) SWIG_fail;
6965 }
6966 resultobj = SWIG_Py_Void();
6967 if (SWIG_IsTmpObj(res1)) {
6968 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6969 } else {
6970 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6972 }
6973 if (SWIG_IsTmpObj(res2)) {
6974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6975 } else {
6976 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6978 }
6979 if (SWIG_IsTmpObj(res3)) {
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6981 } else {
6982 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6984 }
6985 if (SWIG_IsTmpObj(res4)) {
6986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6987 } else {
6988 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6990 }
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6998 PyObject *resultobj = 0;
6999 wxRect result;
7000
7001 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7002 {
7003 if (!wxPyCheckForApp()) SWIG_fail;
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 result = wxGetClientDisplayRect();
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxCursor *arg1 = 0 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 PyObject * obj0 = 0 ;
7022 char * kwnames[] = {
7023 (char *) "cursor", NULL
7024 };
7025
7026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7027 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7028 if (!SWIG_IsOK(res1)) {
7029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7030 }
7031 if (!argp1) {
7032 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7033 }
7034 arg1 = reinterpret_cast< wxCursor * >(argp1);
7035 {
7036 if (!wxPyCheckForApp()) SWIG_fail;
7037 PyThreadState* __tstate = wxPyBeginAllowThreads();
7038 wxSetCursor(*arg1);
7039 wxPyEndAllowThreads(__tstate);
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 resultobj = SWIG_Py_Void();
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7050 PyObject *resultobj = 0;
7051 void *result = 0 ;
7052
7053 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7054 {
7055 if (!wxPyCheckForApp()) SWIG_fail;
7056 PyThreadState* __tstate = wxPyBeginAllowThreads();
7057 result = (void *)wxGetXDisplay();
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7062 return resultobj;
7063 fail:
7064 return NULL;
7065 }
7066
7067
7068 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7069 PyObject *resultobj = 0;
7070 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7071 void *argp1 = 0 ;
7072 int res1 = 0 ;
7073 PyObject * obj0 = 0 ;
7074 char * kwnames[] = {
7075 (char *) "cursor", NULL
7076 };
7077
7078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7079 if (obj0) {
7080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7081 if (!SWIG_IsOK(res1)) {
7082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7083 }
7084 arg1 = reinterpret_cast< wxCursor * >(argp1);
7085 }
7086 {
7087 if (!wxPyCheckForApp()) SWIG_fail;
7088 PyThreadState* __tstate = wxPyBeginAllowThreads();
7089 wxBeginBusyCursor(arg1);
7090 wxPyEndAllowThreads(__tstate);
7091 if (PyErr_Occurred()) SWIG_fail;
7092 }
7093 resultobj = SWIG_Py_Void();
7094 return resultobj;
7095 fail:
7096 return NULL;
7097 }
7098
7099
7100 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7101 PyObject *resultobj = 0;
7102 wxPoint result;
7103
7104 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7105 {
7106 if (!wxPyCheckForApp()) SWIG_fail;
7107 PyThreadState* __tstate = wxPyBeginAllowThreads();
7108 result = wxGetMousePosition();
7109 wxPyEndAllowThreads(__tstate);
7110 if (PyErr_Occurred()) SWIG_fail;
7111 }
7112 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7113 return resultobj;
7114 fail:
7115 return NULL;
7116 }
7117
7118
7119 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7120 PyObject *resultobj = 0;
7121 wxWindow *result = 0 ;
7122
7123 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7124 {
7125 if (!wxPyCheckForApp()) SWIG_fail;
7126 PyThreadState* __tstate = wxPyBeginAllowThreads();
7127 result = (wxWindow *)FindWindowAtPointer();
7128 wxPyEndAllowThreads(__tstate);
7129 if (PyErr_Occurred()) SWIG_fail;
7130 }
7131 {
7132 resultobj = wxPyMake_wxObject(result, 0);
7133 }
7134 return resultobj;
7135 fail:
7136 return NULL;
7137 }
7138
7139
7140 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7141 PyObject *resultobj = 0;
7142 wxWindow *result = 0 ;
7143
7144 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7145 {
7146 if (!wxPyCheckForApp()) SWIG_fail;
7147 PyThreadState* __tstate = wxPyBeginAllowThreads();
7148 result = (wxWindow *)wxGetActiveWindow();
7149 wxPyEndAllowThreads(__tstate);
7150 if (PyErr_Occurred()) SWIG_fail;
7151 }
7152 {
7153 resultobj = wxPyMake_wxObject(result, 0);
7154 }
7155 return resultobj;
7156 fail:
7157 return NULL;
7158 }
7159
7160
7161 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7162 PyObject *resultobj = 0;
7163 wxPoint *arg1 = 0 ;
7164 wxWindow *result = 0 ;
7165 wxPoint temp1 ;
7166 PyObject * obj0 = 0 ;
7167 char * kwnames[] = {
7168 (char *) "pt", NULL
7169 };
7170
7171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7172 {
7173 arg1 = &temp1;
7174 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7175 }
7176 {
7177 if (!wxPyCheckForApp()) SWIG_fail;
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7180 wxPyEndAllowThreads(__tstate);
7181 if (PyErr_Occurred()) SWIG_fail;
7182 }
7183 {
7184 resultobj = wxPyMake_wxObject(result, 0);
7185 }
7186 return resultobj;
7187 fail:
7188 return NULL;
7189 }
7190
7191
7192 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7193 PyObject *resultobj = 0;
7194 wxPoint *arg1 = 0 ;
7195 wxWindow *result = 0 ;
7196 wxPoint temp1 ;
7197 PyObject * obj0 = 0 ;
7198 char * kwnames[] = {
7199 (char *) "pt", NULL
7200 };
7201
7202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7203 {
7204 arg1 = &temp1;
7205 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7206 }
7207 {
7208 if (!wxPyCheckForApp()) SWIG_fail;
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 {
7215 resultobj = wxPyMake_wxObject(result, 0);
7216 }
7217 return resultobj;
7218 fail:
7219 return NULL;
7220 }
7221
7222
7223 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7224 PyObject *resultobj = 0;
7225 wxWindow *arg1 = (wxWindow *) 0 ;
7226 wxWindow *result = 0 ;
7227 void *argp1 = 0 ;
7228 int res1 = 0 ;
7229 PyObject * obj0 = 0 ;
7230 char * kwnames[] = {
7231 (char *) "win", NULL
7232 };
7233
7234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7236 if (!SWIG_IsOK(res1)) {
7237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7238 }
7239 arg1 = reinterpret_cast< wxWindow * >(argp1);
7240 {
7241 if (!wxPyCheckForApp()) SWIG_fail;
7242 PyThreadState* __tstate = wxPyBeginAllowThreads();
7243 result = (wxWindow *)wxGetTopLevelParent(arg1);
7244 wxPyEndAllowThreads(__tstate);
7245 if (PyErr_Occurred()) SWIG_fail;
7246 }
7247 {
7248 resultobj = wxPyMake_wxObject(result, 0);
7249 }
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj = 0;
7258 wxString *arg1 = 0 ;
7259 bool result;
7260 bool temp1 = false ;
7261 PyObject * obj0 = 0 ;
7262 char * kwnames[] = {
7263 (char *) "url", NULL
7264 };
7265
7266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7267 {
7268 arg1 = wxString_in_helper(obj0);
7269 if (arg1 == NULL) SWIG_fail;
7270 temp1 = true;
7271 }
7272 {
7273 PyThreadState* __tstate = wxPyBeginAllowThreads();
7274 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7275 wxPyEndAllowThreads(__tstate);
7276 if (PyErr_Occurred()) SWIG_fail;
7277 }
7278 {
7279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7280 }
7281 {
7282 if (temp1)
7283 delete arg1;
7284 }
7285 return resultobj;
7286 fail:
7287 {
7288 if (temp1)
7289 delete arg1;
7290 }
7291 return NULL;
7292 }
7293
7294
7295 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj = 0;
7297 wxKeyCode arg1 ;
7298 bool result;
7299 int val1 ;
7300 int ecode1 = 0 ;
7301 PyObject * obj0 = 0 ;
7302 char * kwnames[] = {
7303 (char *) "key", NULL
7304 };
7305
7306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7307 ecode1 = SWIG_AsVal_int(obj0, &val1);
7308 if (!SWIG_IsOK(ecode1)) {
7309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7310 }
7311 arg1 = static_cast< wxKeyCode >(val1);
7312 {
7313 if (!wxPyCheckForApp()) SWIG_fail;
7314 PyThreadState* __tstate = wxPyBeginAllowThreads();
7315 result = (bool)wxGetKeyState(arg1);
7316 wxPyEndAllowThreads(__tstate);
7317 if (PyErr_Occurred()) SWIG_fail;
7318 }
7319 {
7320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7321 }
7322 return resultobj;
7323 fail:
7324 return NULL;
7325 }
7326
7327
7328 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7329 PyObject *resultobj = 0;
7330 wxMouseState *result = 0 ;
7331
7332 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 result = (wxMouseState *)new wxMouseState();
7336 wxPyEndAllowThreads(__tstate);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7347 PyObject *resultobj = 0;
7348 wxMouseState *arg1 = (wxMouseState *) 0 ;
7349 void *argp1 = 0 ;
7350 int res1 = 0 ;
7351 PyObject *swig_obj[1] ;
7352
7353 if (!args) SWIG_fail;
7354 swig_obj[0] = args;
7355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7356 if (!SWIG_IsOK(res1)) {
7357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7358 }
7359 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7360 {
7361 PyThreadState* __tstate = wxPyBeginAllowThreads();
7362 delete arg1;
7363
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 resultobj = SWIG_Py_Void();
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7375 PyObject *resultobj = 0;
7376 wxMouseState *arg1 = (wxMouseState *) 0 ;
7377 int result;
7378 void *argp1 = 0 ;
7379 int res1 = 0 ;
7380 PyObject *swig_obj[1] ;
7381
7382 if (!args) SWIG_fail;
7383 swig_obj[0] = args;
7384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7385 if (!SWIG_IsOK(res1)) {
7386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7387 }
7388 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7389 {
7390 PyThreadState* __tstate = wxPyBeginAllowThreads();
7391 result = (int)(arg1)->GetX();
7392 wxPyEndAllowThreads(__tstate);
7393 if (PyErr_Occurred()) SWIG_fail;
7394 }
7395 resultobj = SWIG_From_int(static_cast< int >(result));
7396 return resultobj;
7397 fail:
7398 return NULL;
7399 }
7400
7401
7402 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7403 PyObject *resultobj = 0;
7404 wxMouseState *arg1 = (wxMouseState *) 0 ;
7405 int result;
7406 void *argp1 = 0 ;
7407 int res1 = 0 ;
7408 PyObject *swig_obj[1] ;
7409
7410 if (!args) SWIG_fail;
7411 swig_obj[0] = args;
7412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7413 if (!SWIG_IsOK(res1)) {
7414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7415 }
7416 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7417 {
7418 PyThreadState* __tstate = wxPyBeginAllowThreads();
7419 result = (int)(arg1)->GetY();
7420 wxPyEndAllowThreads(__tstate);
7421 if (PyErr_Occurred()) SWIG_fail;
7422 }
7423 resultobj = SWIG_From_int(static_cast< int >(result));
7424 return resultobj;
7425 fail:
7426 return NULL;
7427 }
7428
7429
7430 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7431 PyObject *resultobj = 0;
7432 wxMouseState *arg1 = (wxMouseState *) 0 ;
7433 bool result;
7434 void *argp1 = 0 ;
7435 int res1 = 0 ;
7436 PyObject *swig_obj[1] ;
7437
7438 if (!args) SWIG_fail;
7439 swig_obj[0] = args;
7440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7441 if (!SWIG_IsOK(res1)) {
7442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7443 }
7444 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7445 {
7446 PyThreadState* __tstate = wxPyBeginAllowThreads();
7447 result = (bool)(arg1)->LeftDown();
7448 wxPyEndAllowThreads(__tstate);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 {
7452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7461 PyObject *resultobj = 0;
7462 wxMouseState *arg1 = (wxMouseState *) 0 ;
7463 bool result;
7464 void *argp1 = 0 ;
7465 int res1 = 0 ;
7466 PyObject *swig_obj[1] ;
7467
7468 if (!args) SWIG_fail;
7469 swig_obj[0] = args;
7470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7471 if (!SWIG_IsOK(res1)) {
7472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7473 }
7474 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7475 {
7476 PyThreadState* __tstate = wxPyBeginAllowThreads();
7477 result = (bool)(arg1)->MiddleDown();
7478 wxPyEndAllowThreads(__tstate);
7479 if (PyErr_Occurred()) SWIG_fail;
7480 }
7481 {
7482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7483 }
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7491 PyObject *resultobj = 0;
7492 wxMouseState *arg1 = (wxMouseState *) 0 ;
7493 bool result;
7494 void *argp1 = 0 ;
7495 int res1 = 0 ;
7496 PyObject *swig_obj[1] ;
7497
7498 if (!args) SWIG_fail;
7499 swig_obj[0] = args;
7500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7501 if (!SWIG_IsOK(res1)) {
7502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7503 }
7504 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7505 {
7506 PyThreadState* __tstate = wxPyBeginAllowThreads();
7507 result = (bool)(arg1)->RightDown();
7508 wxPyEndAllowThreads(__tstate);
7509 if (PyErr_Occurred()) SWIG_fail;
7510 }
7511 {
7512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7513 }
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7521 PyObject *resultobj = 0;
7522 wxMouseState *arg1 = (wxMouseState *) 0 ;
7523 bool result;
7524 void *argp1 = 0 ;
7525 int res1 = 0 ;
7526 PyObject *swig_obj[1] ;
7527
7528 if (!args) SWIG_fail;
7529 swig_obj[0] = args;
7530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7531 if (!SWIG_IsOK(res1)) {
7532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7533 }
7534 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 result = (bool)(arg1)->ControlDown();
7538 wxPyEndAllowThreads(__tstate);
7539 if (PyErr_Occurred()) SWIG_fail;
7540 }
7541 {
7542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7543 }
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7551 PyObject *resultobj = 0;
7552 wxMouseState *arg1 = (wxMouseState *) 0 ;
7553 bool result;
7554 void *argp1 = 0 ;
7555 int res1 = 0 ;
7556 PyObject *swig_obj[1] ;
7557
7558 if (!args) SWIG_fail;
7559 swig_obj[0] = args;
7560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7563 }
7564 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7565 {
7566 PyThreadState* __tstate = wxPyBeginAllowThreads();
7567 result = (bool)(arg1)->ShiftDown();
7568 wxPyEndAllowThreads(__tstate);
7569 if (PyErr_Occurred()) SWIG_fail;
7570 }
7571 {
7572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7573 }
7574 return resultobj;
7575 fail:
7576 return NULL;
7577 }
7578
7579
7580 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7581 PyObject *resultobj = 0;
7582 wxMouseState *arg1 = (wxMouseState *) 0 ;
7583 bool result;
7584 void *argp1 = 0 ;
7585 int res1 = 0 ;
7586 PyObject *swig_obj[1] ;
7587
7588 if (!args) SWIG_fail;
7589 swig_obj[0] = args;
7590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7591 if (!SWIG_IsOK(res1)) {
7592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7593 }
7594 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7595 {
7596 PyThreadState* __tstate = wxPyBeginAllowThreads();
7597 result = (bool)(arg1)->AltDown();
7598 wxPyEndAllowThreads(__tstate);
7599 if (PyErr_Occurred()) SWIG_fail;
7600 }
7601 {
7602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7603 }
7604 return resultobj;
7605 fail:
7606 return NULL;
7607 }
7608
7609
7610 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7611 PyObject *resultobj = 0;
7612 wxMouseState *arg1 = (wxMouseState *) 0 ;
7613 bool result;
7614 void *argp1 = 0 ;
7615 int res1 = 0 ;
7616 PyObject *swig_obj[1] ;
7617
7618 if (!args) SWIG_fail;
7619 swig_obj[0] = args;
7620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7621 if (!SWIG_IsOK(res1)) {
7622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7623 }
7624 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7625 {
7626 PyThreadState* __tstate = wxPyBeginAllowThreads();
7627 result = (bool)(arg1)->MetaDown();
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 {
7632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7633 }
7634 return resultobj;
7635 fail:
7636 return NULL;
7637 }
7638
7639
7640 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7641 PyObject *resultobj = 0;
7642 wxMouseState *arg1 = (wxMouseState *) 0 ;
7643 bool result;
7644 void *argp1 = 0 ;
7645 int res1 = 0 ;
7646 PyObject *swig_obj[1] ;
7647
7648 if (!args) SWIG_fail;
7649 swig_obj[0] = args;
7650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7651 if (!SWIG_IsOK(res1)) {
7652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7653 }
7654 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 result = (bool)(arg1)->CmdDown();
7658 wxPyEndAllowThreads(__tstate);
7659 if (PyErr_Occurred()) SWIG_fail;
7660 }
7661 {
7662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7663 }
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj = 0;
7672 wxMouseState *arg1 = (wxMouseState *) 0 ;
7673 int arg2 ;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 int val2 ;
7677 int ecode2 = 0 ;
7678 PyObject * obj0 = 0 ;
7679 PyObject * obj1 = 0 ;
7680 char * kwnames[] = {
7681 (char *) "self",(char *) "x", NULL
7682 };
7683
7684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7686 if (!SWIG_IsOK(res1)) {
7687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7688 }
7689 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7690 ecode2 = SWIG_AsVal_int(obj1, &val2);
7691 if (!SWIG_IsOK(ecode2)) {
7692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7693 }
7694 arg2 = static_cast< int >(val2);
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 (arg1)->SetX(arg2);
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 resultobj = SWIG_Py_Void();
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj = 0;
7710 wxMouseState *arg1 = (wxMouseState *) 0 ;
7711 int arg2 ;
7712 void *argp1 = 0 ;
7713 int res1 = 0 ;
7714 int val2 ;
7715 int ecode2 = 0 ;
7716 PyObject * obj0 = 0 ;
7717 PyObject * obj1 = 0 ;
7718 char * kwnames[] = {
7719 (char *) "self",(char *) "y", NULL
7720 };
7721
7722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7724 if (!SWIG_IsOK(res1)) {
7725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7726 }
7727 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7728 ecode2 = SWIG_AsVal_int(obj1, &val2);
7729 if (!SWIG_IsOK(ecode2)) {
7730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7731 }
7732 arg2 = static_cast< int >(val2);
7733 {
7734 PyThreadState* __tstate = wxPyBeginAllowThreads();
7735 (arg1)->SetY(arg2);
7736 wxPyEndAllowThreads(__tstate);
7737 if (PyErr_Occurred()) SWIG_fail;
7738 }
7739 resultobj = SWIG_Py_Void();
7740 return resultobj;
7741 fail:
7742 return NULL;
7743 }
7744
7745
7746 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7747 PyObject *resultobj = 0;
7748 wxMouseState *arg1 = (wxMouseState *) 0 ;
7749 bool arg2 ;
7750 void *argp1 = 0 ;
7751 int res1 = 0 ;
7752 bool val2 ;
7753 int ecode2 = 0 ;
7754 PyObject * obj0 = 0 ;
7755 PyObject * obj1 = 0 ;
7756 char * kwnames[] = {
7757 (char *) "self",(char *) "down", NULL
7758 };
7759
7760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7762 if (!SWIG_IsOK(res1)) {
7763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7764 }
7765 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7766 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7767 if (!SWIG_IsOK(ecode2)) {
7768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7769 }
7770 arg2 = static_cast< bool >(val2);
7771 {
7772 PyThreadState* __tstate = wxPyBeginAllowThreads();
7773 (arg1)->SetLeftDown(arg2);
7774 wxPyEndAllowThreads(__tstate);
7775 if (PyErr_Occurred()) SWIG_fail;
7776 }
7777 resultobj = SWIG_Py_Void();
7778 return resultobj;
7779 fail:
7780 return NULL;
7781 }
7782
7783
7784 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7785 PyObject *resultobj = 0;
7786 wxMouseState *arg1 = (wxMouseState *) 0 ;
7787 bool arg2 ;
7788 void *argp1 = 0 ;
7789 int res1 = 0 ;
7790 bool val2 ;
7791 int ecode2 = 0 ;
7792 PyObject * obj0 = 0 ;
7793 PyObject * obj1 = 0 ;
7794 char * kwnames[] = {
7795 (char *) "self",(char *) "down", NULL
7796 };
7797
7798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7800 if (!SWIG_IsOK(res1)) {
7801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7802 }
7803 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7804 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7805 if (!SWIG_IsOK(ecode2)) {
7806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7807 }
7808 arg2 = static_cast< bool >(val2);
7809 {
7810 PyThreadState* __tstate = wxPyBeginAllowThreads();
7811 (arg1)->SetMiddleDown(arg2);
7812 wxPyEndAllowThreads(__tstate);
7813 if (PyErr_Occurred()) SWIG_fail;
7814 }
7815 resultobj = SWIG_Py_Void();
7816 return resultobj;
7817 fail:
7818 return NULL;
7819 }
7820
7821
7822 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7823 PyObject *resultobj = 0;
7824 wxMouseState *arg1 = (wxMouseState *) 0 ;
7825 bool arg2 ;
7826 void *argp1 = 0 ;
7827 int res1 = 0 ;
7828 bool val2 ;
7829 int ecode2 = 0 ;
7830 PyObject * obj0 = 0 ;
7831 PyObject * obj1 = 0 ;
7832 char * kwnames[] = {
7833 (char *) "self",(char *) "down", NULL
7834 };
7835
7836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7838 if (!SWIG_IsOK(res1)) {
7839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7840 }
7841 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7843 if (!SWIG_IsOK(ecode2)) {
7844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7845 }
7846 arg2 = static_cast< bool >(val2);
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 (arg1)->SetRightDown(arg2);
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 resultobj = SWIG_Py_Void();
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7861 PyObject *resultobj = 0;
7862 wxMouseState *arg1 = (wxMouseState *) 0 ;
7863 bool arg2 ;
7864 void *argp1 = 0 ;
7865 int res1 = 0 ;
7866 bool val2 ;
7867 int ecode2 = 0 ;
7868 PyObject * obj0 = 0 ;
7869 PyObject * obj1 = 0 ;
7870 char * kwnames[] = {
7871 (char *) "self",(char *) "down", NULL
7872 };
7873
7874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7876 if (!SWIG_IsOK(res1)) {
7877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7878 }
7879 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7880 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7881 if (!SWIG_IsOK(ecode2)) {
7882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7883 }
7884 arg2 = static_cast< bool >(val2);
7885 {
7886 PyThreadState* __tstate = wxPyBeginAllowThreads();
7887 (arg1)->SetControlDown(arg2);
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 resultobj = SWIG_Py_Void();
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7899 PyObject *resultobj = 0;
7900 wxMouseState *arg1 = (wxMouseState *) 0 ;
7901 bool arg2 ;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 bool val2 ;
7905 int ecode2 = 0 ;
7906 PyObject * obj0 = 0 ;
7907 PyObject * obj1 = 0 ;
7908 char * kwnames[] = {
7909 (char *) "self",(char *) "down", NULL
7910 };
7911
7912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7914 if (!SWIG_IsOK(res1)) {
7915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7916 }
7917 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7918 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7919 if (!SWIG_IsOK(ecode2)) {
7920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7921 }
7922 arg2 = static_cast< bool >(val2);
7923 {
7924 PyThreadState* __tstate = wxPyBeginAllowThreads();
7925 (arg1)->SetShiftDown(arg2);
7926 wxPyEndAllowThreads(__tstate);
7927 if (PyErr_Occurred()) SWIG_fail;
7928 }
7929 resultobj = SWIG_Py_Void();
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj = 0;
7938 wxMouseState *arg1 = (wxMouseState *) 0 ;
7939 bool arg2 ;
7940 void *argp1 = 0 ;
7941 int res1 = 0 ;
7942 bool val2 ;
7943 int ecode2 = 0 ;
7944 PyObject * obj0 = 0 ;
7945 PyObject * obj1 = 0 ;
7946 char * kwnames[] = {
7947 (char *) "self",(char *) "down", NULL
7948 };
7949
7950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7952 if (!SWIG_IsOK(res1)) {
7953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7954 }
7955 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7956 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7957 if (!SWIG_IsOK(ecode2)) {
7958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7959 }
7960 arg2 = static_cast< bool >(val2);
7961 {
7962 PyThreadState* __tstate = wxPyBeginAllowThreads();
7963 (arg1)->SetAltDown(arg2);
7964 wxPyEndAllowThreads(__tstate);
7965 if (PyErr_Occurred()) SWIG_fail;
7966 }
7967 resultobj = SWIG_Py_Void();
7968 return resultobj;
7969 fail:
7970 return NULL;
7971 }
7972
7973
7974 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7975 PyObject *resultobj = 0;
7976 wxMouseState *arg1 = (wxMouseState *) 0 ;
7977 bool arg2 ;
7978 void *argp1 = 0 ;
7979 int res1 = 0 ;
7980 bool val2 ;
7981 int ecode2 = 0 ;
7982 PyObject * obj0 = 0 ;
7983 PyObject * obj1 = 0 ;
7984 char * kwnames[] = {
7985 (char *) "self",(char *) "down", NULL
7986 };
7987
7988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7990 if (!SWIG_IsOK(res1)) {
7991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7992 }
7993 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7994 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7995 if (!SWIG_IsOK(ecode2)) {
7996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7997 }
7998 arg2 = static_cast< bool >(val2);
7999 {
8000 PyThreadState* __tstate = wxPyBeginAllowThreads();
8001 (arg1)->SetMetaDown(arg2);
8002 wxPyEndAllowThreads(__tstate);
8003 if (PyErr_Occurred()) SWIG_fail;
8004 }
8005 resultobj = SWIG_Py_Void();
8006 return resultobj;
8007 fail:
8008 return NULL;
8009 }
8010
8011
8012 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8013 PyObject *obj;
8014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8015 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8016 return SWIG_Py_Void();
8017 }
8018
8019 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8020 return SWIG_Python_InitShadowInstance(args);
8021 }
8022
8023 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025 wxMouseState result;
8026
8027 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8028 {
8029 PyThreadState* __tstate = wxPyBeginAllowThreads();
8030 result = wxGetMouseState();
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8035 return resultobj;
8036 fail:
8037 return NULL;
8038 }
8039
8040
8041 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8042 PyObject *resultobj = 0;
8043
8044 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8045 {
8046 if (!wxPyCheckForApp()) SWIG_fail;
8047 PyThreadState* __tstate = wxPyBeginAllowThreads();
8048 wxWakeUpMainThread();
8049 wxPyEndAllowThreads(__tstate);
8050 if (PyErr_Occurred()) SWIG_fail;
8051 }
8052 resultobj = SWIG_Py_Void();
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8060 PyObject *resultobj = 0;
8061
8062 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8063 {
8064 if (!wxPyCheckForApp()) SWIG_fail;
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 wxMutexGuiEnter();
8067 wxPyEndAllowThreads(__tstate);
8068 if (PyErr_Occurred()) SWIG_fail;
8069 }
8070 resultobj = SWIG_Py_Void();
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8078 PyObject *resultobj = 0;
8079
8080 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8081 {
8082 if (!wxPyCheckForApp()) SWIG_fail;
8083 PyThreadState* __tstate = wxPyBeginAllowThreads();
8084 wxMutexGuiLeave();
8085 wxPyEndAllowThreads(__tstate);
8086 if (PyErr_Occurred()) SWIG_fail;
8087 }
8088 resultobj = SWIG_Py_Void();
8089 return resultobj;
8090 fail:
8091 return NULL;
8092 }
8093
8094
8095 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8096 PyObject *resultobj = 0;
8097 wxMutexGuiLocker *result = 0 ;
8098
8099 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8100 {
8101 if (!wxPyCheckForApp()) SWIG_fail;
8102 PyThreadState* __tstate = wxPyBeginAllowThreads();
8103 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8104 wxPyEndAllowThreads(__tstate);
8105 if (PyErr_Occurred()) SWIG_fail;
8106 }
8107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8108 return resultobj;
8109 fail:
8110 return NULL;
8111 }
8112
8113
8114 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8115 PyObject *resultobj = 0;
8116 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8117 void *argp1 = 0 ;
8118 int res1 = 0 ;
8119 PyObject *swig_obj[1] ;
8120
8121 if (!args) SWIG_fail;
8122 swig_obj[0] = args;
8123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8124 if (!SWIG_IsOK(res1)) {
8125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8126 }
8127 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8128 {
8129 PyThreadState* __tstate = wxPyBeginAllowThreads();
8130 delete arg1;
8131
8132 wxPyEndAllowThreads(__tstate);
8133 if (PyErr_Occurred()) SWIG_fail;
8134 }
8135 resultobj = SWIG_Py_Void();
8136 return resultobj;
8137 fail:
8138 return NULL;
8139 }
8140
8141
8142 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8143 PyObject *obj;
8144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8145 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8146 return SWIG_Py_Void();
8147 }
8148
8149 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8150 return SWIG_Python_InitShadowInstance(args);
8151 }
8152
8153 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8154 PyObject *resultobj = 0;
8155 bool result;
8156
8157 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 result = (bool)wxThread_IsMain();
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 {
8165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8166 }
8167 return resultobj;
8168 fail:
8169 return NULL;
8170 }
8171
8172
8173 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8174 PyObject *resultobj = 0;
8175 wxString *arg1 = 0 ;
8176 wxToolTip *result = 0 ;
8177 bool temp1 = false ;
8178 PyObject * obj0 = 0 ;
8179 char * kwnames[] = {
8180 (char *) "tip", NULL
8181 };
8182
8183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8184 {
8185 arg1 = wxString_in_helper(obj0);
8186 if (arg1 == NULL) SWIG_fail;
8187 temp1 = true;
8188 }
8189 {
8190 if (!wxPyCheckForApp()) SWIG_fail;
8191 PyThreadState* __tstate = wxPyBeginAllowThreads();
8192 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8193 wxPyEndAllowThreads(__tstate);
8194 if (PyErr_Occurred()) SWIG_fail;
8195 }
8196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8197 {
8198 if (temp1)
8199 delete arg1;
8200 }
8201 return resultobj;
8202 fail:
8203 {
8204 if (temp1)
8205 delete arg1;
8206 }
8207 return NULL;
8208 }
8209
8210
8211 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8212 PyObject *resultobj = 0;
8213 wxToolTip *arg1 = (wxToolTip *) 0 ;
8214 void *argp1 = 0 ;
8215 int res1 = 0 ;
8216 PyObject *swig_obj[1] ;
8217
8218 if (!args) SWIG_fail;
8219 swig_obj[0] = args;
8220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8221 if (!SWIG_IsOK(res1)) {
8222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8223 }
8224 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8225 {
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 delete arg1;
8228
8229 wxPyEndAllowThreads(__tstate);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_Py_Void();
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8240 PyObject *resultobj = 0;
8241 wxToolTip *arg1 = (wxToolTip *) 0 ;
8242 wxString *arg2 = 0 ;
8243 void *argp1 = 0 ;
8244 int res1 = 0 ;
8245 bool temp2 = false ;
8246 PyObject * obj0 = 0 ;
8247 PyObject * obj1 = 0 ;
8248 char * kwnames[] = {
8249 (char *) "self",(char *) "tip", NULL
8250 };
8251
8252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8254 if (!SWIG_IsOK(res1)) {
8255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8256 }
8257 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8258 {
8259 arg2 = wxString_in_helper(obj1);
8260 if (arg2 == NULL) SWIG_fail;
8261 temp2 = true;
8262 }
8263 {
8264 PyThreadState* __tstate = wxPyBeginAllowThreads();
8265 (arg1)->SetTip((wxString const &)*arg2);
8266 wxPyEndAllowThreads(__tstate);
8267 if (PyErr_Occurred()) SWIG_fail;
8268 }
8269 resultobj = SWIG_Py_Void();
8270 {
8271 if (temp2)
8272 delete arg2;
8273 }
8274 return resultobj;
8275 fail:
8276 {
8277 if (temp2)
8278 delete arg2;
8279 }
8280 return NULL;
8281 }
8282
8283
8284 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8285 PyObject *resultobj = 0;
8286 wxToolTip *arg1 = (wxToolTip *) 0 ;
8287 wxString result;
8288 void *argp1 = 0 ;
8289 int res1 = 0 ;
8290 PyObject *swig_obj[1] ;
8291
8292 if (!args) SWIG_fail;
8293 swig_obj[0] = args;
8294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8295 if (!SWIG_IsOK(res1)) {
8296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8297 }
8298 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8299 {
8300 PyThreadState* __tstate = wxPyBeginAllowThreads();
8301 result = (arg1)->GetTip();
8302 wxPyEndAllowThreads(__tstate);
8303 if (PyErr_Occurred()) SWIG_fail;
8304 }
8305 {
8306 #if wxUSE_UNICODE
8307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8308 #else
8309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8310 #endif
8311 }
8312 return resultobj;
8313 fail:
8314 return NULL;
8315 }
8316
8317
8318 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8319 PyObject *resultobj = 0;
8320 wxToolTip *arg1 = (wxToolTip *) 0 ;
8321 wxWindow *result = 0 ;
8322 void *argp1 = 0 ;
8323 int res1 = 0 ;
8324 PyObject *swig_obj[1] ;
8325
8326 if (!args) SWIG_fail;
8327 swig_obj[0] = args;
8328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8329 if (!SWIG_IsOK(res1)) {
8330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8331 }
8332 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8333 {
8334 PyThreadState* __tstate = wxPyBeginAllowThreads();
8335 result = (wxWindow *)(arg1)->GetWindow();
8336 wxPyEndAllowThreads(__tstate);
8337 if (PyErr_Occurred()) SWIG_fail;
8338 }
8339 {
8340 resultobj = wxPyMake_wxObject(result, 0);
8341 }
8342 return resultobj;
8343 fail:
8344 return NULL;
8345 }
8346
8347
8348 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8349 PyObject *resultobj = 0;
8350 bool arg1 ;
8351 bool val1 ;
8352 int ecode1 = 0 ;
8353 PyObject * obj0 = 0 ;
8354 char * kwnames[] = {
8355 (char *) "flag", NULL
8356 };
8357
8358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8359 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8360 if (!SWIG_IsOK(ecode1)) {
8361 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8362 }
8363 arg1 = static_cast< bool >(val1);
8364 {
8365 PyThreadState* __tstate = wxPyBeginAllowThreads();
8366 wxToolTip::Enable(arg1);
8367 wxPyEndAllowThreads(__tstate);
8368 if (PyErr_Occurred()) SWIG_fail;
8369 }
8370 resultobj = SWIG_Py_Void();
8371 return resultobj;
8372 fail:
8373 return NULL;
8374 }
8375
8376
8377 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8378 PyObject *resultobj = 0;
8379 long arg1 ;
8380 long val1 ;
8381 int ecode1 = 0 ;
8382 PyObject * obj0 = 0 ;
8383 char * kwnames[] = {
8384 (char *) "milliseconds", NULL
8385 };
8386
8387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8388 ecode1 = SWIG_AsVal_long(obj0, &val1);
8389 if (!SWIG_IsOK(ecode1)) {
8390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8391 }
8392 arg1 = static_cast< long >(val1);
8393 {
8394 PyThreadState* __tstate = wxPyBeginAllowThreads();
8395 wxToolTip::SetDelay(arg1);
8396 wxPyEndAllowThreads(__tstate);
8397 if (PyErr_Occurred()) SWIG_fail;
8398 }
8399 resultobj = SWIG_Py_Void();
8400 return resultobj;
8401 fail:
8402 return NULL;
8403 }
8404
8405
8406 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8407 PyObject *obj;
8408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8409 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8410 return SWIG_Py_Void();
8411 }
8412
8413 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8414 return SWIG_Python_InitShadowInstance(args);
8415 }
8416
8417 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8418 PyObject *resultobj = 0;
8419 wxWindow *arg1 = (wxWindow *) 0 ;
8420 wxSize *arg2 = 0 ;
8421 wxCaret *result = 0 ;
8422 void *argp1 = 0 ;
8423 int res1 = 0 ;
8424 wxSize temp2 ;
8425 PyObject * obj0 = 0 ;
8426 PyObject * obj1 = 0 ;
8427 char * kwnames[] = {
8428 (char *) "window",(char *) "size", NULL
8429 };
8430
8431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8433 if (!SWIG_IsOK(res1)) {
8434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8435 }
8436 arg1 = reinterpret_cast< wxWindow * >(argp1);
8437 {
8438 arg2 = &temp2;
8439 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8440 }
8441 {
8442 if (!wxPyCheckForApp()) SWIG_fail;
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8445 wxPyEndAllowThreads(__tstate);
8446 if (PyErr_Occurred()) SWIG_fail;
8447 }
8448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8449 return resultobj;
8450 fail:
8451 return NULL;
8452 }
8453
8454
8455 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8456 PyObject *resultobj = 0;
8457 wxCaret *arg1 = (wxCaret *) 0 ;
8458 void *argp1 = 0 ;
8459 int res1 = 0 ;
8460 PyObject *swig_obj[1] ;
8461
8462 if (!args) SWIG_fail;
8463 swig_obj[0] = args;
8464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8465 if (!SWIG_IsOK(res1)) {
8466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8467 }
8468 arg1 = reinterpret_cast< wxCaret * >(argp1);
8469 {
8470 PyThreadState* __tstate = wxPyBeginAllowThreads();
8471 delete arg1;
8472
8473 wxPyEndAllowThreads(__tstate);
8474 if (PyErr_Occurred()) SWIG_fail;
8475 }
8476 resultobj = SWIG_Py_Void();
8477 return resultobj;
8478 fail:
8479 return NULL;
8480 }
8481
8482
8483 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8484 PyObject *resultobj = 0;
8485 wxCaret *arg1 = (wxCaret *) 0 ;
8486 void *argp1 = 0 ;
8487 int res1 = 0 ;
8488 PyObject *swig_obj[1] ;
8489
8490 if (!args) SWIG_fail;
8491 swig_obj[0] = args;
8492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8493 if (!SWIG_IsOK(res1)) {
8494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8495 }
8496 arg1 = reinterpret_cast< wxCaret * >(argp1);
8497 {
8498 PyThreadState* __tstate = wxPyBeginAllowThreads();
8499 wxCaret_Destroy(arg1);
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 resultobj = SWIG_Py_Void();
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8511 PyObject *resultobj = 0;
8512 wxCaret *arg1 = (wxCaret *) 0 ;
8513 bool result;
8514 void *argp1 = 0 ;
8515 int res1 = 0 ;
8516 PyObject *swig_obj[1] ;
8517
8518 if (!args) SWIG_fail;
8519 swig_obj[0] = args;
8520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8521 if (!SWIG_IsOK(res1)) {
8522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8523 }
8524 arg1 = reinterpret_cast< wxCaret * >(argp1);
8525 {
8526 PyThreadState* __tstate = wxPyBeginAllowThreads();
8527 result = (bool)(arg1)->IsOk();
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 {
8532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8533 }
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8541 PyObject *resultobj = 0;
8542 wxCaret *arg1 = (wxCaret *) 0 ;
8543 bool result;
8544 void *argp1 = 0 ;
8545 int res1 = 0 ;
8546 PyObject *swig_obj[1] ;
8547
8548 if (!args) SWIG_fail;
8549 swig_obj[0] = args;
8550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8551 if (!SWIG_IsOK(res1)) {
8552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8553 }
8554 arg1 = reinterpret_cast< wxCaret * >(argp1);
8555 {
8556 PyThreadState* __tstate = wxPyBeginAllowThreads();
8557 result = (bool)(arg1)->IsVisible();
8558 wxPyEndAllowThreads(__tstate);
8559 if (PyErr_Occurred()) SWIG_fail;
8560 }
8561 {
8562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8563 }
8564 return resultobj;
8565 fail:
8566 return NULL;
8567 }
8568
8569
8570 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8571 PyObject *resultobj = 0;
8572 wxCaret *arg1 = (wxCaret *) 0 ;
8573 wxPoint result;
8574 void *argp1 = 0 ;
8575 int res1 = 0 ;
8576 PyObject *swig_obj[1] ;
8577
8578 if (!args) SWIG_fail;
8579 swig_obj[0] = args;
8580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8581 if (!SWIG_IsOK(res1)) {
8582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8583 }
8584 arg1 = reinterpret_cast< wxCaret * >(argp1);
8585 {
8586 PyThreadState* __tstate = wxPyBeginAllowThreads();
8587 result = (arg1)->GetPosition();
8588 wxPyEndAllowThreads(__tstate);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8599 PyObject *resultobj = 0;
8600 wxCaret *arg1 = (wxCaret *) 0 ;
8601 int *arg2 = (int *) 0 ;
8602 int *arg3 = (int *) 0 ;
8603 void *argp1 = 0 ;
8604 int res1 = 0 ;
8605 int temp2 ;
8606 int res2 = SWIG_TMPOBJ ;
8607 int temp3 ;
8608 int res3 = SWIG_TMPOBJ ;
8609 PyObject *swig_obj[1] ;
8610
8611 arg2 = &temp2;
8612 arg3 = &temp3;
8613 if (!args) SWIG_fail;
8614 swig_obj[0] = args;
8615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8616 if (!SWIG_IsOK(res1)) {
8617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8618 }
8619 arg1 = reinterpret_cast< wxCaret * >(argp1);
8620 {
8621 PyThreadState* __tstate = wxPyBeginAllowThreads();
8622 (arg1)->GetPosition(arg2,arg3);
8623 wxPyEndAllowThreads(__tstate);
8624 if (PyErr_Occurred()) SWIG_fail;
8625 }
8626 resultobj = SWIG_Py_Void();
8627 if (SWIG_IsTmpObj(res2)) {
8628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8629 } else {
8630 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8632 }
8633 if (SWIG_IsTmpObj(res3)) {
8634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8635 } else {
8636 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8638 }
8639 return resultobj;
8640 fail:
8641 return NULL;
8642 }
8643
8644
8645 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8646 PyObject *resultobj = 0;
8647 wxCaret *arg1 = (wxCaret *) 0 ;
8648 wxSize result;
8649 void *argp1 = 0 ;
8650 int res1 = 0 ;
8651 PyObject *swig_obj[1] ;
8652
8653 if (!args) SWIG_fail;
8654 swig_obj[0] = args;
8655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8656 if (!SWIG_IsOK(res1)) {
8657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8658 }
8659 arg1 = reinterpret_cast< wxCaret * >(argp1);
8660 {
8661 PyThreadState* __tstate = wxPyBeginAllowThreads();
8662 result = (arg1)->GetSize();
8663 wxPyEndAllowThreads(__tstate);
8664 if (PyErr_Occurred()) SWIG_fail;
8665 }
8666 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8667 return resultobj;
8668 fail:
8669 return NULL;
8670 }
8671
8672
8673 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8674 PyObject *resultobj = 0;
8675 wxCaret *arg1 = (wxCaret *) 0 ;
8676 int *arg2 = (int *) 0 ;
8677 int *arg3 = (int *) 0 ;
8678 void *argp1 = 0 ;
8679 int res1 = 0 ;
8680 int temp2 ;
8681 int res2 = SWIG_TMPOBJ ;
8682 int temp3 ;
8683 int res3 = SWIG_TMPOBJ ;
8684 PyObject *swig_obj[1] ;
8685
8686 arg2 = &temp2;
8687 arg3 = &temp3;
8688 if (!args) SWIG_fail;
8689 swig_obj[0] = args;
8690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8691 if (!SWIG_IsOK(res1)) {
8692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8693 }
8694 arg1 = reinterpret_cast< wxCaret * >(argp1);
8695 {
8696 PyThreadState* __tstate = wxPyBeginAllowThreads();
8697 (arg1)->GetSize(arg2,arg3);
8698 wxPyEndAllowThreads(__tstate);
8699 if (PyErr_Occurred()) SWIG_fail;
8700 }
8701 resultobj = SWIG_Py_Void();
8702 if (SWIG_IsTmpObj(res2)) {
8703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8704 } else {
8705 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8707 }
8708 if (SWIG_IsTmpObj(res3)) {
8709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8710 } else {
8711 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8713 }
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8721 PyObject *resultobj = 0;
8722 wxCaret *arg1 = (wxCaret *) 0 ;
8723 wxWindow *result = 0 ;
8724 void *argp1 = 0 ;
8725 int res1 = 0 ;
8726 PyObject *swig_obj[1] ;
8727
8728 if (!args) SWIG_fail;
8729 swig_obj[0] = args;
8730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8731 if (!SWIG_IsOK(res1)) {
8732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8733 }
8734 arg1 = reinterpret_cast< wxCaret * >(argp1);
8735 {
8736 PyThreadState* __tstate = wxPyBeginAllowThreads();
8737 result = (wxWindow *)(arg1)->GetWindow();
8738 wxPyEndAllowThreads(__tstate);
8739 if (PyErr_Occurred()) SWIG_fail;
8740 }
8741 {
8742 resultobj = wxPyMake_wxObject(result, 0);
8743 }
8744 return resultobj;
8745 fail:
8746 return NULL;
8747 }
8748
8749
8750 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8751 PyObject *resultobj = 0;
8752 wxCaret *arg1 = (wxCaret *) 0 ;
8753 int arg2 ;
8754 int arg3 ;
8755 void *argp1 = 0 ;
8756 int res1 = 0 ;
8757 int val2 ;
8758 int ecode2 = 0 ;
8759 int val3 ;
8760 int ecode3 = 0 ;
8761 PyObject * obj0 = 0 ;
8762 PyObject * obj1 = 0 ;
8763 PyObject * obj2 = 0 ;
8764 char * kwnames[] = {
8765 (char *) "self",(char *) "x",(char *) "y", NULL
8766 };
8767
8768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8770 if (!SWIG_IsOK(res1)) {
8771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8772 }
8773 arg1 = reinterpret_cast< wxCaret * >(argp1);
8774 ecode2 = SWIG_AsVal_int(obj1, &val2);
8775 if (!SWIG_IsOK(ecode2)) {
8776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8777 }
8778 arg2 = static_cast< int >(val2);
8779 ecode3 = SWIG_AsVal_int(obj2, &val3);
8780 if (!SWIG_IsOK(ecode3)) {
8781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8782 }
8783 arg3 = static_cast< int >(val3);
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 (arg1)->Move(arg2,arg3);
8787 wxPyEndAllowThreads(__tstate);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 resultobj = SWIG_Py_Void();
8791 return resultobj;
8792 fail:
8793 return NULL;
8794 }
8795
8796
8797 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj = 0;
8799 wxCaret *arg1 = (wxCaret *) 0 ;
8800 wxPoint *arg2 = 0 ;
8801 void *argp1 = 0 ;
8802 int res1 = 0 ;
8803 wxPoint temp2 ;
8804 PyObject * obj0 = 0 ;
8805 PyObject * obj1 = 0 ;
8806 char * kwnames[] = {
8807 (char *) "self",(char *) "pt", NULL
8808 };
8809
8810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8812 if (!SWIG_IsOK(res1)) {
8813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8814 }
8815 arg1 = reinterpret_cast< wxCaret * >(argp1);
8816 {
8817 arg2 = &temp2;
8818 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8819 }
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 (arg1)->Move((wxPoint const &)*arg2);
8823 wxPyEndAllowThreads(__tstate);
8824 if (PyErr_Occurred()) SWIG_fail;
8825 }
8826 resultobj = SWIG_Py_Void();
8827 return resultobj;
8828 fail:
8829 return NULL;
8830 }
8831
8832
8833 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8834 PyObject *resultobj = 0;
8835 wxCaret *arg1 = (wxCaret *) 0 ;
8836 int arg2 ;
8837 int arg3 ;
8838 void *argp1 = 0 ;
8839 int res1 = 0 ;
8840 int val2 ;
8841 int ecode2 = 0 ;
8842 int val3 ;
8843 int ecode3 = 0 ;
8844 PyObject * obj0 = 0 ;
8845 PyObject * obj1 = 0 ;
8846 PyObject * obj2 = 0 ;
8847 char * kwnames[] = {
8848 (char *) "self",(char *) "width",(char *) "height", NULL
8849 };
8850
8851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8853 if (!SWIG_IsOK(res1)) {
8854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8855 }
8856 arg1 = reinterpret_cast< wxCaret * >(argp1);
8857 ecode2 = SWIG_AsVal_int(obj1, &val2);
8858 if (!SWIG_IsOK(ecode2)) {
8859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8860 }
8861 arg2 = static_cast< int >(val2);
8862 ecode3 = SWIG_AsVal_int(obj2, &val3);
8863 if (!SWIG_IsOK(ecode3)) {
8864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8865 }
8866 arg3 = static_cast< int >(val3);
8867 {
8868 PyThreadState* __tstate = wxPyBeginAllowThreads();
8869 (arg1)->SetSize(arg2,arg3);
8870 wxPyEndAllowThreads(__tstate);
8871 if (PyErr_Occurred()) SWIG_fail;
8872 }
8873 resultobj = SWIG_Py_Void();
8874 return resultobj;
8875 fail:
8876 return NULL;
8877 }
8878
8879
8880 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8881 PyObject *resultobj = 0;
8882 wxCaret *arg1 = (wxCaret *) 0 ;
8883 wxSize *arg2 = 0 ;
8884 void *argp1 = 0 ;
8885 int res1 = 0 ;
8886 wxSize temp2 ;
8887 PyObject * obj0 = 0 ;
8888 PyObject * obj1 = 0 ;
8889 char * kwnames[] = {
8890 (char *) "self",(char *) "size", NULL
8891 };
8892
8893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8895 if (!SWIG_IsOK(res1)) {
8896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8897 }
8898 arg1 = reinterpret_cast< wxCaret * >(argp1);
8899 {
8900 arg2 = &temp2;
8901 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8902 }
8903 {
8904 PyThreadState* __tstate = wxPyBeginAllowThreads();
8905 (arg1)->SetSize((wxSize const &)*arg2);
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 resultobj = SWIG_Py_Void();
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8917 PyObject *resultobj = 0;
8918 wxCaret *arg1 = (wxCaret *) 0 ;
8919 int arg2 = (int) true ;
8920 void *argp1 = 0 ;
8921 int res1 = 0 ;
8922 int val2 ;
8923 int ecode2 = 0 ;
8924 PyObject * obj0 = 0 ;
8925 PyObject * obj1 = 0 ;
8926 char * kwnames[] = {
8927 (char *) "self",(char *) "show", NULL
8928 };
8929
8930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8932 if (!SWIG_IsOK(res1)) {
8933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8934 }
8935 arg1 = reinterpret_cast< wxCaret * >(argp1);
8936 if (obj1) {
8937 ecode2 = SWIG_AsVal_int(obj1, &val2);
8938 if (!SWIG_IsOK(ecode2)) {
8939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8940 }
8941 arg2 = static_cast< int >(val2);
8942 }
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 (arg1)->Show(arg2);
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8957 PyObject *resultobj = 0;
8958 wxCaret *arg1 = (wxCaret *) 0 ;
8959 void *argp1 = 0 ;
8960 int res1 = 0 ;
8961 PyObject *swig_obj[1] ;
8962
8963 if (!args) SWIG_fail;
8964 swig_obj[0] = args;
8965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8966 if (!SWIG_IsOK(res1)) {
8967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8968 }
8969 arg1 = reinterpret_cast< wxCaret * >(argp1);
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 (arg1)->Hide();
8973 wxPyEndAllowThreads(__tstate);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 resultobj = SWIG_Py_Void();
8977 return resultobj;
8978 fail:
8979 return NULL;
8980 }
8981
8982
8983 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8984 PyObject *resultobj = 0;
8985 int result;
8986
8987 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8988 {
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 result = (int)wxCaret::GetBlinkTime();
8991 wxPyEndAllowThreads(__tstate);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 resultobj = SWIG_From_int(static_cast< int >(result));
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9002 PyObject *resultobj = 0;
9003 int arg1 ;
9004 int val1 ;
9005 int ecode1 = 0 ;
9006 PyObject * obj0 = 0 ;
9007 char * kwnames[] = {
9008 (char *) "milliseconds", NULL
9009 };
9010
9011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9012 ecode1 = SWIG_AsVal_int(obj0, &val1);
9013 if (!SWIG_IsOK(ecode1)) {
9014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9015 }
9016 arg1 = static_cast< int >(val1);
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 wxCaret::SetBlinkTime(arg1);
9020 wxPyEndAllowThreads(__tstate);
9021 if (PyErr_Occurred()) SWIG_fail;
9022 }
9023 resultobj = SWIG_Py_Void();
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9031 PyObject *obj;
9032 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9033 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9034 return SWIG_Py_Void();
9035 }
9036
9037 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9038 return SWIG_Python_InitShadowInstance(args);
9039 }
9040
9041 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj = 0;
9043 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9044 wxBusyCursor *result = 0 ;
9045 void *argp1 = 0 ;
9046 int res1 = 0 ;
9047 PyObject * obj0 = 0 ;
9048 char * kwnames[] = {
9049 (char *) "cursor", NULL
9050 };
9051
9052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9053 if (obj0) {
9054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9055 if (!SWIG_IsOK(res1)) {
9056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9057 }
9058 arg1 = reinterpret_cast< wxCursor * >(argp1);
9059 }
9060 {
9061 if (!wxPyCheckForApp()) SWIG_fail;
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9064 wxPyEndAllowThreads(__tstate);
9065 if (PyErr_Occurred()) SWIG_fail;
9066 }
9067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9068 return resultobj;
9069 fail:
9070 return NULL;
9071 }
9072
9073
9074 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9075 PyObject *resultobj = 0;
9076 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9077 void *argp1 = 0 ;
9078 int res1 = 0 ;
9079 PyObject *swig_obj[1] ;
9080
9081 if (!args) SWIG_fail;
9082 swig_obj[0] = args;
9083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9084 if (!SWIG_IsOK(res1)) {
9085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9086 }
9087 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9088 {
9089 PyThreadState* __tstate = wxPyBeginAllowThreads();
9090 delete arg1;
9091
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 resultobj = SWIG_Py_Void();
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 PyObject *obj;
9104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9105 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9106 return SWIG_Py_Void();
9107 }
9108
9109 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9110 return SWIG_Python_InitShadowInstance(args);
9111 }
9112
9113 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj = 0;
9115 wxWindow *arg1 = (wxWindow *) NULL ;
9116 wxWindowDisabler *result = 0 ;
9117 void *argp1 = 0 ;
9118 int res1 = 0 ;
9119 PyObject * obj0 = 0 ;
9120 char * kwnames[] = {
9121 (char *) "winToSkip", NULL
9122 };
9123
9124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9125 if (obj0) {
9126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9127 if (!SWIG_IsOK(res1)) {
9128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9129 }
9130 arg1 = reinterpret_cast< wxWindow * >(argp1);
9131 }
9132 {
9133 if (!wxPyCheckForApp()) SWIG_fail;
9134 PyThreadState* __tstate = wxPyBeginAllowThreads();
9135 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9140 return resultobj;
9141 fail:
9142 return NULL;
9143 }
9144
9145
9146 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9147 PyObject *resultobj = 0;
9148 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9149 void *argp1 = 0 ;
9150 int res1 = 0 ;
9151 PyObject *swig_obj[1] ;
9152
9153 if (!args) SWIG_fail;
9154 swig_obj[0] = args;
9155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9156 if (!SWIG_IsOK(res1)) {
9157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9158 }
9159 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 delete arg1;
9163
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 resultobj = SWIG_Py_Void();
9168 return resultobj;
9169 fail:
9170 return NULL;
9171 }
9172
9173
9174 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9175 PyObject *obj;
9176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9177 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9178 return SWIG_Py_Void();
9179 }
9180
9181 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9182 return SWIG_Python_InitShadowInstance(args);
9183 }
9184
9185 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj = 0;
9187 wxString *arg1 = 0 ;
9188 wxWindow *arg2 = (wxWindow *) NULL ;
9189 wxBusyInfo *result = 0 ;
9190 bool temp1 = false ;
9191 void *argp2 = 0 ;
9192 int res2 = 0 ;
9193 PyObject * obj0 = 0 ;
9194 PyObject * obj1 = 0 ;
9195 char * kwnames[] = {
9196 (char *) "message",(char *) "parent", NULL
9197 };
9198
9199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9200 {
9201 arg1 = wxString_in_helper(obj0);
9202 if (arg1 == NULL) SWIG_fail;
9203 temp1 = true;
9204 }
9205 if (obj1) {
9206 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9207 if (!SWIG_IsOK(res2)) {
9208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9209 }
9210 arg2 = reinterpret_cast< wxWindow * >(argp2);
9211 }
9212 {
9213 if (!wxPyCheckForApp()) SWIG_fail;
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9220 {
9221 if (temp1)
9222 delete arg1;
9223 }
9224 return resultobj;
9225 fail:
9226 {
9227 if (temp1)
9228 delete arg1;
9229 }
9230 return NULL;
9231 }
9232
9233
9234 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9235 PyObject *resultobj = 0;
9236 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9237 void *argp1 = 0 ;
9238 int res1 = 0 ;
9239 PyObject *swig_obj[1] ;
9240
9241 if (!args) SWIG_fail;
9242 swig_obj[0] = args;
9243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9244 if (!SWIG_IsOK(res1)) {
9245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9246 }
9247 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9248 {
9249 PyThreadState* __tstate = wxPyBeginAllowThreads();
9250 delete arg1;
9251
9252 wxPyEndAllowThreads(__tstate);
9253 if (PyErr_Occurred()) SWIG_fail;
9254 }
9255 resultobj = SWIG_Py_Void();
9256 return resultobj;
9257 fail:
9258 return NULL;
9259 }
9260
9261
9262 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9263 PyObject *obj;
9264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9265 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9266 return SWIG_Py_Void();
9267 }
9268
9269 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9270 return SWIG_Python_InitShadowInstance(args);
9271 }
9272
9273 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9274 PyObject *resultobj = 0;
9275 wxStopWatch *result = 0 ;
9276
9277 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9278 {
9279 PyThreadState* __tstate = wxPyBeginAllowThreads();
9280 result = (wxStopWatch *)new wxStopWatch();
9281 wxPyEndAllowThreads(__tstate);
9282 if (PyErr_Occurred()) SWIG_fail;
9283 }
9284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9285 return resultobj;
9286 fail:
9287 return NULL;
9288 }
9289
9290
9291 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9292 PyObject *resultobj = 0;
9293 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9294 void *argp1 = 0 ;
9295 int res1 = 0 ;
9296 PyObject *swig_obj[1] ;
9297
9298 if (!args) SWIG_fail;
9299 swig_obj[0] = args;
9300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9301 if (!SWIG_IsOK(res1)) {
9302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9303 }
9304 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 delete arg1;
9308
9309 wxPyEndAllowThreads(__tstate);
9310 if (PyErr_Occurred()) SWIG_fail;
9311 }
9312 resultobj = SWIG_Py_Void();
9313 return resultobj;
9314 fail:
9315 return NULL;
9316 }
9317
9318
9319 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9320 PyObject *resultobj = 0;
9321 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9322 long arg2 = (long) 0 ;
9323 void *argp1 = 0 ;
9324 int res1 = 0 ;
9325 long val2 ;
9326 int ecode2 = 0 ;
9327 PyObject * obj0 = 0 ;
9328 PyObject * obj1 = 0 ;
9329 char * kwnames[] = {
9330 (char *) "self",(char *) "t0", NULL
9331 };
9332
9333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9335 if (!SWIG_IsOK(res1)) {
9336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9337 }
9338 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9339 if (obj1) {
9340 ecode2 = SWIG_AsVal_long(obj1, &val2);
9341 if (!SWIG_IsOK(ecode2)) {
9342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9343 }
9344 arg2 = static_cast< long >(val2);
9345 }
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 (arg1)->Start(arg2);
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 resultobj = SWIG_Py_Void();
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9360 PyObject *resultobj = 0;
9361 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9362 void *argp1 = 0 ;
9363 int res1 = 0 ;
9364 PyObject *swig_obj[1] ;
9365
9366 if (!args) SWIG_fail;
9367 swig_obj[0] = args;
9368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9369 if (!SWIG_IsOK(res1)) {
9370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9371 }
9372 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9373 {
9374 PyThreadState* __tstate = wxPyBeginAllowThreads();
9375 (arg1)->Pause();
9376 wxPyEndAllowThreads(__tstate);
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 resultobj = SWIG_Py_Void();
9380 return resultobj;
9381 fail:
9382 return NULL;
9383 }
9384
9385
9386 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9387 PyObject *resultobj = 0;
9388 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9389 void *argp1 = 0 ;
9390 int res1 = 0 ;
9391 PyObject *swig_obj[1] ;
9392
9393 if (!args) SWIG_fail;
9394 swig_obj[0] = args;
9395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9396 if (!SWIG_IsOK(res1)) {
9397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9398 }
9399 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9400 {
9401 PyThreadState* __tstate = wxPyBeginAllowThreads();
9402 (arg1)->Resume();
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 resultobj = SWIG_Py_Void();
9407 return resultobj;
9408 fail:
9409 return NULL;
9410 }
9411
9412
9413 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9414 PyObject *resultobj = 0;
9415 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9416 long result;
9417 void *argp1 = 0 ;
9418 int res1 = 0 ;
9419 PyObject *swig_obj[1] ;
9420
9421 if (!args) SWIG_fail;
9422 swig_obj[0] = args;
9423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9424 if (!SWIG_IsOK(res1)) {
9425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9426 }
9427 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9428 {
9429 PyThreadState* __tstate = wxPyBeginAllowThreads();
9430 result = (long)((wxStopWatch const *)arg1)->Time();
9431 wxPyEndAllowThreads(__tstate);
9432 if (PyErr_Occurred()) SWIG_fail;
9433 }
9434 resultobj = SWIG_From_long(static_cast< long >(result));
9435 return resultobj;
9436 fail:
9437 return NULL;
9438 }
9439
9440
9441 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9442 PyObject *obj;
9443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9444 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9445 return SWIG_Py_Void();
9446 }
9447
9448 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9449 return SWIG_Python_InitShadowInstance(args);
9450 }
9451
9452 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9453 PyObject *resultobj = 0;
9454 int arg1 = (int) 9 ;
9455 int arg2 = (int) wxID_FILE1 ;
9456 wxFileHistory *result = 0 ;
9457 int val1 ;
9458 int ecode1 = 0 ;
9459 int val2 ;
9460 int ecode2 = 0 ;
9461 PyObject * obj0 = 0 ;
9462 PyObject * obj1 = 0 ;
9463 char * kwnames[] = {
9464 (char *) "maxFiles",(char *) "idBase", NULL
9465 };
9466
9467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9468 if (obj0) {
9469 ecode1 = SWIG_AsVal_int(obj0, &val1);
9470 if (!SWIG_IsOK(ecode1)) {
9471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9472 }
9473 arg1 = static_cast< int >(val1);
9474 }
9475 if (obj1) {
9476 ecode2 = SWIG_AsVal_int(obj1, &val2);
9477 if (!SWIG_IsOK(ecode2)) {
9478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9479 }
9480 arg2 = static_cast< int >(val2);
9481 }
9482 {
9483 PyThreadState* __tstate = wxPyBeginAllowThreads();
9484 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9485 wxPyEndAllowThreads(__tstate);
9486 if (PyErr_Occurred()) SWIG_fail;
9487 }
9488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9489 return resultobj;
9490 fail:
9491 return NULL;
9492 }
9493
9494
9495 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9496 PyObject *resultobj = 0;
9497 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9498 void *argp1 = 0 ;
9499 int res1 = 0 ;
9500 PyObject *swig_obj[1] ;
9501
9502 if (!args) SWIG_fail;
9503 swig_obj[0] = args;
9504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9505 if (!SWIG_IsOK(res1)) {
9506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9507 }
9508 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9509 {
9510 PyThreadState* __tstate = wxPyBeginAllowThreads();
9511 delete arg1;
9512
9513 wxPyEndAllowThreads(__tstate);
9514 if (PyErr_Occurred()) SWIG_fail;
9515 }
9516 resultobj = SWIG_Py_Void();
9517 return resultobj;
9518 fail:
9519 return NULL;
9520 }
9521
9522
9523 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9524 PyObject *resultobj = 0;
9525 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9526 wxString *arg2 = 0 ;
9527 void *argp1 = 0 ;
9528 int res1 = 0 ;
9529 bool temp2 = false ;
9530 PyObject * obj0 = 0 ;
9531 PyObject * obj1 = 0 ;
9532 char * kwnames[] = {
9533 (char *) "self",(char *) "file", NULL
9534 };
9535
9536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9538 if (!SWIG_IsOK(res1)) {
9539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9540 }
9541 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9542 {
9543 arg2 = wxString_in_helper(obj1);
9544 if (arg2 == NULL) SWIG_fail;
9545 temp2 = true;
9546 }
9547 {
9548 PyThreadState* __tstate = wxPyBeginAllowThreads();
9549 (arg1)->AddFileToHistory((wxString const &)*arg2);
9550 wxPyEndAllowThreads(__tstate);
9551 if (PyErr_Occurred()) SWIG_fail;
9552 }
9553 resultobj = SWIG_Py_Void();
9554 {
9555 if (temp2)
9556 delete arg2;
9557 }
9558 return resultobj;
9559 fail:
9560 {
9561 if (temp2)
9562 delete arg2;
9563 }
9564 return NULL;
9565 }
9566
9567
9568 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9569 PyObject *resultobj = 0;
9570 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9571 int arg2 ;
9572 void *argp1 = 0 ;
9573 int res1 = 0 ;
9574 int val2 ;
9575 int ecode2 = 0 ;
9576 PyObject * obj0 = 0 ;
9577 PyObject * obj1 = 0 ;
9578 char * kwnames[] = {
9579 (char *) "self",(char *) "i", NULL
9580 };
9581
9582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9584 if (!SWIG_IsOK(res1)) {
9585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9586 }
9587 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9588 ecode2 = SWIG_AsVal_int(obj1, &val2);
9589 if (!SWIG_IsOK(ecode2)) {
9590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9591 }
9592 arg2 = static_cast< int >(val2);
9593 {
9594 PyThreadState* __tstate = wxPyBeginAllowThreads();
9595 (arg1)->RemoveFileFromHistory(arg2);
9596 wxPyEndAllowThreads(__tstate);
9597 if (PyErr_Occurred()) SWIG_fail;
9598 }
9599 resultobj = SWIG_Py_Void();
9600 return resultobj;
9601 fail:
9602 return NULL;
9603 }
9604
9605
9606 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9607 PyObject *resultobj = 0;
9608 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9609 int result;
9610 void *argp1 = 0 ;
9611 int res1 = 0 ;
9612 PyObject *swig_obj[1] ;
9613
9614 if (!args) SWIG_fail;
9615 swig_obj[0] = args;
9616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9617 if (!SWIG_IsOK(res1)) {
9618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9619 }
9620 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9621 {
9622 PyThreadState* __tstate = wxPyBeginAllowThreads();
9623 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9624 wxPyEndAllowThreads(__tstate);
9625 if (PyErr_Occurred()) SWIG_fail;
9626 }
9627 resultobj = SWIG_From_int(static_cast< int >(result));
9628 return resultobj;
9629 fail:
9630 return NULL;
9631 }
9632
9633
9634 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = 0;
9636 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9637 wxMenu *arg2 = (wxMenu *) 0 ;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 void *argp2 = 0 ;
9641 int res2 = 0 ;
9642 PyObject * obj0 = 0 ;
9643 PyObject * obj1 = 0 ;
9644 char * kwnames[] = {
9645 (char *) "self",(char *) "menu", NULL
9646 };
9647
9648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9650 if (!SWIG_IsOK(res1)) {
9651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9652 }
9653 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9654 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9655 if (!SWIG_IsOK(res2)) {
9656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9657 }
9658 arg2 = reinterpret_cast< wxMenu * >(argp2);
9659 {
9660 PyThreadState* __tstate = wxPyBeginAllowThreads();
9661 (arg1)->UseMenu(arg2);
9662 wxPyEndAllowThreads(__tstate);
9663 if (PyErr_Occurred()) SWIG_fail;
9664 }
9665 resultobj = SWIG_Py_Void();
9666 return resultobj;
9667 fail:
9668 return NULL;
9669 }
9670
9671
9672 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9673 PyObject *resultobj = 0;
9674 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9675 wxMenu *arg2 = (wxMenu *) 0 ;
9676 void *argp1 = 0 ;
9677 int res1 = 0 ;
9678 void *argp2 = 0 ;
9679 int res2 = 0 ;
9680 PyObject * obj0 = 0 ;
9681 PyObject * obj1 = 0 ;
9682 char * kwnames[] = {
9683 (char *) "self",(char *) "menu", NULL
9684 };
9685
9686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9688 if (!SWIG_IsOK(res1)) {
9689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9690 }
9691 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9692 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9693 if (!SWIG_IsOK(res2)) {
9694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9695 }
9696 arg2 = reinterpret_cast< wxMenu * >(argp2);
9697 {
9698 PyThreadState* __tstate = wxPyBeginAllowThreads();
9699 (arg1)->RemoveMenu(arg2);
9700 wxPyEndAllowThreads(__tstate);
9701 if (PyErr_Occurred()) SWIG_fail;
9702 }
9703 resultobj = SWIG_Py_Void();
9704 return resultobj;
9705 fail:
9706 return NULL;
9707 }
9708
9709
9710 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9711 PyObject *resultobj = 0;
9712 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9713 wxConfigBase *arg2 = 0 ;
9714 void *argp1 = 0 ;
9715 int res1 = 0 ;
9716 void *argp2 = 0 ;
9717 int res2 = 0 ;
9718 PyObject * obj0 = 0 ;
9719 PyObject * obj1 = 0 ;
9720 char * kwnames[] = {
9721 (char *) "self",(char *) "config", NULL
9722 };
9723
9724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9726 if (!SWIG_IsOK(res1)) {
9727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9728 }
9729 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9730 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9731 if (!SWIG_IsOK(res2)) {
9732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9733 }
9734 if (!argp2) {
9735 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9736 }
9737 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9738 {
9739 PyThreadState* __tstate = wxPyBeginAllowThreads();
9740 (arg1)->Load(*arg2);
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 resultobj = SWIG_Py_Void();
9745 return resultobj;
9746 fail:
9747 return NULL;
9748 }
9749
9750
9751 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9752 PyObject *resultobj = 0;
9753 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9754 wxConfigBase *arg2 = 0 ;
9755 void *argp1 = 0 ;
9756 int res1 = 0 ;
9757 void *argp2 = 0 ;
9758 int res2 = 0 ;
9759 PyObject * obj0 = 0 ;
9760 PyObject * obj1 = 0 ;
9761 char * kwnames[] = {
9762 (char *) "self",(char *) "config", NULL
9763 };
9764
9765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9767 if (!SWIG_IsOK(res1)) {
9768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9769 }
9770 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9771 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9772 if (!SWIG_IsOK(res2)) {
9773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9774 }
9775 if (!argp2) {
9776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9777 }
9778 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9779 {
9780 PyThreadState* __tstate = wxPyBeginAllowThreads();
9781 (arg1)->Save(*arg2);
9782 wxPyEndAllowThreads(__tstate);
9783 if (PyErr_Occurred()) SWIG_fail;
9784 }
9785 resultobj = SWIG_Py_Void();
9786 return resultobj;
9787 fail:
9788 return NULL;
9789 }
9790
9791
9792 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9793 PyObject *resultobj = 0;
9794 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9795 void *argp1 = 0 ;
9796 int res1 = 0 ;
9797 PyObject *swig_obj[1] ;
9798
9799 if (!args) SWIG_fail;
9800 swig_obj[0] = args;
9801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9804 }
9805 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9806 {
9807 PyThreadState* __tstate = wxPyBeginAllowThreads();
9808 (arg1)->AddFilesToMenu();
9809 wxPyEndAllowThreads(__tstate);
9810 if (PyErr_Occurred()) SWIG_fail;
9811 }
9812 resultobj = SWIG_Py_Void();
9813 return resultobj;
9814 fail:
9815 return NULL;
9816 }
9817
9818
9819 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9820 PyObject *resultobj = 0;
9821 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9822 wxMenu *arg2 = (wxMenu *) 0 ;
9823 void *argp1 = 0 ;
9824 int res1 = 0 ;
9825 void *argp2 = 0 ;
9826 int res2 = 0 ;
9827 PyObject * obj0 = 0 ;
9828 PyObject * obj1 = 0 ;
9829 char * kwnames[] = {
9830 (char *) "self",(char *) "menu", NULL
9831 };
9832
9833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9835 if (!SWIG_IsOK(res1)) {
9836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9837 }
9838 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9839 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9840 if (!SWIG_IsOK(res2)) {
9841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9842 }
9843 arg2 = reinterpret_cast< wxMenu * >(argp2);
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 (arg1)->AddFilesToMenu(arg2);
9847 wxPyEndAllowThreads(__tstate);
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 resultobj = SWIG_Py_Void();
9851 return resultobj;
9852 fail:
9853 return NULL;
9854 }
9855
9856
9857 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9858 PyObject *resultobj = 0;
9859 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9860 int arg2 ;
9861 wxString result;
9862 void *argp1 = 0 ;
9863 int res1 = 0 ;
9864 int val2 ;
9865 int ecode2 = 0 ;
9866 PyObject * obj0 = 0 ;
9867 PyObject * obj1 = 0 ;
9868 char * kwnames[] = {
9869 (char *) "self",(char *) "i", NULL
9870 };
9871
9872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9874 if (!SWIG_IsOK(res1)) {
9875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9876 }
9877 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9878 ecode2 = SWIG_AsVal_int(obj1, &val2);
9879 if (!SWIG_IsOK(ecode2)) {
9880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9881 }
9882 arg2 = static_cast< int >(val2);
9883 {
9884 PyThreadState* __tstate = wxPyBeginAllowThreads();
9885 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9886 wxPyEndAllowThreads(__tstate);
9887 if (PyErr_Occurred()) SWIG_fail;
9888 }
9889 {
9890 #if wxUSE_UNICODE
9891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9892 #else
9893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9894 #endif
9895 }
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 PyObject *resultobj = 0;
9904 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9905 int result;
9906 void *argp1 = 0 ;
9907 int res1 = 0 ;
9908 PyObject *swig_obj[1] ;
9909
9910 if (!args) SWIG_fail;
9911 swig_obj[0] = args;
9912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9913 if (!SWIG_IsOK(res1)) {
9914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9915 }
9916 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 result = (int)((wxFileHistory const *)arg1)->GetCount();
9920 wxPyEndAllowThreads(__tstate);
9921 if (PyErr_Occurred()) SWIG_fail;
9922 }
9923 resultobj = SWIG_From_int(static_cast< int >(result));
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931 PyObject *obj;
9932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9933 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9934 return SWIG_Py_Void();
9935 }
9936
9937 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9938 return SWIG_Python_InitShadowInstance(args);
9939 }
9940
9941 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9942 PyObject *resultobj = 0;
9943 wxString *arg1 = 0 ;
9944 wxString const &arg2_defvalue = wxPyEmptyString ;
9945 wxString *arg2 = (wxString *) &arg2_defvalue ;
9946 wxSingleInstanceChecker *result = 0 ;
9947 bool temp1 = false ;
9948 bool temp2 = false ;
9949 PyObject * obj0 = 0 ;
9950 PyObject * obj1 = 0 ;
9951 char * kwnames[] = {
9952 (char *) "name",(char *) "path", NULL
9953 };
9954
9955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9956 {
9957 arg1 = wxString_in_helper(obj0);
9958 if (arg1 == NULL) SWIG_fail;
9959 temp1 = true;
9960 }
9961 if (obj1) {
9962 {
9963 arg2 = wxString_in_helper(obj1);
9964 if (arg2 == NULL) SWIG_fail;
9965 temp2 = true;
9966 }
9967 }
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9971 wxPyEndAllowThreads(__tstate);
9972 if (PyErr_Occurred()) SWIG_fail;
9973 }
9974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9975 {
9976 if (temp1)
9977 delete arg1;
9978 }
9979 {
9980 if (temp2)
9981 delete arg2;
9982 }
9983 return resultobj;
9984 fail:
9985 {
9986 if (temp1)
9987 delete arg1;
9988 }
9989 {
9990 if (temp2)
9991 delete arg2;
9992 }
9993 return NULL;
9994 }
9995
9996
9997 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9998 PyObject *resultobj = 0;
9999 wxSingleInstanceChecker *result = 0 ;
10000
10001 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
10002 {
10003 PyThreadState* __tstate = wxPyBeginAllowThreads();
10004 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10009 return resultobj;
10010 fail:
10011 return NULL;
10012 }
10013
10014
10015 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10016 PyObject *resultobj = 0;
10017 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10018 void *argp1 = 0 ;
10019 int res1 = 0 ;
10020 PyObject *swig_obj[1] ;
10021
10022 if (!args) SWIG_fail;
10023 swig_obj[0] = args;
10024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10025 if (!SWIG_IsOK(res1)) {
10026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10027 }
10028 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10029 {
10030 PyThreadState* __tstate = wxPyBeginAllowThreads();
10031 delete arg1;
10032
10033 wxPyEndAllowThreads(__tstate);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 resultobj = SWIG_Py_Void();
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10044 PyObject *resultobj = 0;
10045 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10046 wxString *arg2 = 0 ;
10047 wxString const &arg3_defvalue = wxPyEmptyString ;
10048 wxString *arg3 = (wxString *) &arg3_defvalue ;
10049 bool result;
10050 void *argp1 = 0 ;
10051 int res1 = 0 ;
10052 bool temp2 = false ;
10053 bool temp3 = false ;
10054 PyObject * obj0 = 0 ;
10055 PyObject * obj1 = 0 ;
10056 PyObject * obj2 = 0 ;
10057 char * kwnames[] = {
10058 (char *) "self",(char *) "name",(char *) "path", NULL
10059 };
10060
10061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10063 if (!SWIG_IsOK(res1)) {
10064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10065 }
10066 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10067 {
10068 arg2 = wxString_in_helper(obj1);
10069 if (arg2 == NULL) SWIG_fail;
10070 temp2 = true;
10071 }
10072 if (obj2) {
10073 {
10074 arg3 = wxString_in_helper(obj2);
10075 if (arg3 == NULL) SWIG_fail;
10076 temp3 = true;
10077 }
10078 }
10079 {
10080 PyThreadState* __tstate = wxPyBeginAllowThreads();
10081 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10082 wxPyEndAllowThreads(__tstate);
10083 if (PyErr_Occurred()) SWIG_fail;
10084 }
10085 {
10086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10087 }
10088 {
10089 if (temp2)
10090 delete arg2;
10091 }
10092 {
10093 if (temp3)
10094 delete arg3;
10095 }
10096 return resultobj;
10097 fail:
10098 {
10099 if (temp2)
10100 delete arg2;
10101 }
10102 {
10103 if (temp3)
10104 delete arg3;
10105 }
10106 return NULL;
10107 }
10108
10109
10110 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10111 PyObject *resultobj = 0;
10112 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10113 bool result;
10114 void *argp1 = 0 ;
10115 int res1 = 0 ;
10116 PyObject *swig_obj[1] ;
10117
10118 if (!args) SWIG_fail;
10119 swig_obj[0] = args;
10120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10121 if (!SWIG_IsOK(res1)) {
10122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10123 }
10124 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10125 {
10126 PyThreadState* __tstate = wxPyBeginAllowThreads();
10127 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10128 wxPyEndAllowThreads(__tstate);
10129 if (PyErr_Occurred()) SWIG_fail;
10130 }
10131 {
10132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10133 }
10134 return resultobj;
10135 fail:
10136 return NULL;
10137 }
10138
10139
10140 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10141 PyObject *obj;
10142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10143 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10144 return SWIG_Py_Void();
10145 }
10146
10147 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10148 return SWIG_Python_InitShadowInstance(args);
10149 }
10150
10151 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10152 PyObject *resultobj = 0;
10153 wxPlatformInfo *result = 0 ;
10154
10155 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10156 {
10157 PyThreadState* __tstate = wxPyBeginAllowThreads();
10158 result = (wxPlatformInfo *)new wxPlatformInfo();
10159 wxPyEndAllowThreads(__tstate);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10163 return resultobj;
10164 fail:
10165 return NULL;
10166 }
10167
10168
10169 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10170 PyObject *resultobj = 0;
10171 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10172 wxPlatformInfo *arg2 = 0 ;
10173 bool result;
10174 void *argp1 = 0 ;
10175 int res1 = 0 ;
10176 void *argp2 = 0 ;
10177 int res2 = 0 ;
10178 PyObject * obj0 = 0 ;
10179 PyObject * obj1 = 0 ;
10180 char * kwnames[] = {
10181 (char *) "self",(char *) "t", NULL
10182 };
10183
10184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10186 if (!SWIG_IsOK(res1)) {
10187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10188 }
10189 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10190 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10191 if (!SWIG_IsOK(res2)) {
10192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10193 }
10194 if (!argp2) {
10195 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10196 }
10197 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10198 {
10199 PyThreadState* __tstate = wxPyBeginAllowThreads();
10200 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10201 wxPyEndAllowThreads(__tstate);
10202 if (PyErr_Occurred()) SWIG_fail;
10203 }
10204 {
10205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10206 }
10207 return resultobj;
10208 fail:
10209 return NULL;
10210 }
10211
10212
10213 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10214 PyObject *resultobj = 0;
10215 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10216 wxPlatformInfo *arg2 = 0 ;
10217 bool result;
10218 void *argp1 = 0 ;
10219 int res1 = 0 ;
10220 void *argp2 = 0 ;
10221 int res2 = 0 ;
10222 PyObject * obj0 = 0 ;
10223 PyObject * obj1 = 0 ;
10224 char * kwnames[] = {
10225 (char *) "self",(char *) "t", NULL
10226 };
10227
10228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10230 if (!SWIG_IsOK(res1)) {
10231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10232 }
10233 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10234 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10235 if (!SWIG_IsOK(res2)) {
10236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10237 }
10238 if (!argp2) {
10239 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10240 }
10241 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10242 {
10243 PyThreadState* __tstate = wxPyBeginAllowThreads();
10244 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10245 wxPyEndAllowThreads(__tstate);
10246 if (PyErr_Occurred()) SWIG_fail;
10247 }
10248 {
10249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10250 }
10251 return resultobj;
10252 fail:
10253 return NULL;
10254 }
10255
10256
10257 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10258 PyObject *resultobj = 0;
10259 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10260 int result;
10261 void *argp1 = 0 ;
10262 int res1 = 0 ;
10263 PyObject *swig_obj[1] ;
10264
10265 if (!args) SWIG_fail;
10266 swig_obj[0] = args;
10267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10268 if (!SWIG_IsOK(res1)) {
10269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10270 }
10271 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10272 {
10273 PyThreadState* __tstate = wxPyBeginAllowThreads();
10274 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10275 wxPyEndAllowThreads(__tstate);
10276 if (PyErr_Occurred()) SWIG_fail;
10277 }
10278 resultobj = SWIG_From_int(static_cast< int >(result));
10279 return resultobj;
10280 fail:
10281 return NULL;
10282 }
10283
10284
10285 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10286 PyObject *resultobj = 0;
10287 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10288 int result;
10289 void *argp1 = 0 ;
10290 int res1 = 0 ;
10291 PyObject *swig_obj[1] ;
10292
10293 if (!args) SWIG_fail;
10294 swig_obj[0] = args;
10295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10296 if (!SWIG_IsOK(res1)) {
10297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10298 }
10299 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10300 {
10301 PyThreadState* __tstate = wxPyBeginAllowThreads();
10302 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10303 wxPyEndAllowThreads(__tstate);
10304 if (PyErr_Occurred()) SWIG_fail;
10305 }
10306 resultobj = SWIG_From_int(static_cast< int >(result));
10307 return resultobj;
10308 fail:
10309 return NULL;
10310 }
10311
10312
10313 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10314 PyObject *resultobj = 0;
10315 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10316 int arg2 ;
10317 int arg3 ;
10318 bool result;
10319 void *argp1 = 0 ;
10320 int res1 = 0 ;
10321 int val2 ;
10322 int ecode2 = 0 ;
10323 int val3 ;
10324 int ecode3 = 0 ;
10325 PyObject * obj0 = 0 ;
10326 PyObject * obj1 = 0 ;
10327 PyObject * obj2 = 0 ;
10328 char * kwnames[] = {
10329 (char *) "self",(char *) "major",(char *) "minor", NULL
10330 };
10331
10332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10334 if (!SWIG_IsOK(res1)) {
10335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10336 }
10337 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10338 ecode2 = SWIG_AsVal_int(obj1, &val2);
10339 if (!SWIG_IsOK(ecode2)) {
10340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10341 }
10342 arg2 = static_cast< int >(val2);
10343 ecode3 = SWIG_AsVal_int(obj2, &val3);
10344 if (!SWIG_IsOK(ecode3)) {
10345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10346 }
10347 arg3 = static_cast< int >(val3);
10348 {
10349 PyThreadState* __tstate = wxPyBeginAllowThreads();
10350 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10351 wxPyEndAllowThreads(__tstate);
10352 if (PyErr_Occurred()) SWIG_fail;
10353 }
10354 {
10355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10356 }
10357 return resultobj;
10358 fail:
10359 return NULL;
10360 }
10361
10362
10363 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10364 PyObject *resultobj = 0;
10365 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10366 int result;
10367 void *argp1 = 0 ;
10368 int res1 = 0 ;
10369 PyObject *swig_obj[1] ;
10370
10371 if (!args) SWIG_fail;
10372 swig_obj[0] = args;
10373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10374 if (!SWIG_IsOK(res1)) {
10375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10376 }
10377 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 resultobj = SWIG_From_int(static_cast< int >(result));
10385 return resultobj;
10386 fail:
10387 return NULL;
10388 }
10389
10390
10391 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10392 PyObject *resultobj = 0;
10393 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10394 int result;
10395 void *argp1 = 0 ;
10396 int res1 = 0 ;
10397 PyObject *swig_obj[1] ;
10398
10399 if (!args) SWIG_fail;
10400 swig_obj[0] = args;
10401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10402 if (!SWIG_IsOK(res1)) {
10403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10404 }
10405 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10406 {
10407 PyThreadState* __tstate = wxPyBeginAllowThreads();
10408 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10409 wxPyEndAllowThreads(__tstate);
10410 if (PyErr_Occurred()) SWIG_fail;
10411 }
10412 resultobj = SWIG_From_int(static_cast< int >(result));
10413 return resultobj;
10414 fail:
10415 return NULL;
10416 }
10417
10418
10419 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10420 PyObject *resultobj = 0;
10421 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10422 int arg2 ;
10423 int arg3 ;
10424 bool result;
10425 void *argp1 = 0 ;
10426 int res1 = 0 ;
10427 int val2 ;
10428 int ecode2 = 0 ;
10429 int val3 ;
10430 int ecode3 = 0 ;
10431 PyObject * obj0 = 0 ;
10432 PyObject * obj1 = 0 ;
10433 PyObject * obj2 = 0 ;
10434 char * kwnames[] = {
10435 (char *) "self",(char *) "major",(char *) "minor", NULL
10436 };
10437
10438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10440 if (!SWIG_IsOK(res1)) {
10441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10442 }
10443 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10444 ecode2 = SWIG_AsVal_int(obj1, &val2);
10445 if (!SWIG_IsOK(ecode2)) {
10446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10447 }
10448 arg2 = static_cast< int >(val2);
10449 ecode3 = SWIG_AsVal_int(obj2, &val3);
10450 if (!SWIG_IsOK(ecode3)) {
10451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10452 }
10453 arg3 = static_cast< int >(val3);
10454 {
10455 PyThreadState* __tstate = wxPyBeginAllowThreads();
10456 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10457 wxPyEndAllowThreads(__tstate);
10458 if (PyErr_Occurred()) SWIG_fail;
10459 }
10460 {
10461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10462 }
10463 return resultobj;
10464 fail:
10465 return NULL;
10466 }
10467
10468
10469 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10470 PyObject *resultobj = 0;
10471 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10472 bool result;
10473 void *argp1 = 0 ;
10474 int res1 = 0 ;
10475 PyObject *swig_obj[1] ;
10476
10477 if (!args) SWIG_fail;
10478 swig_obj[0] = args;
10479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10480 if (!SWIG_IsOK(res1)) {
10481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10482 }
10483 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10484 {
10485 PyThreadState* __tstate = wxPyBeginAllowThreads();
10486 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10487 wxPyEndAllowThreads(__tstate);
10488 if (PyErr_Occurred()) SWIG_fail;
10489 }
10490 {
10491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10492 }
10493 return resultobj;
10494 fail:
10495 return NULL;
10496 }
10497
10498
10499 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10500 PyObject *resultobj = 0;
10501 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10502 wxOperatingSystemId result;
10503 void *argp1 = 0 ;
10504 int res1 = 0 ;
10505 PyObject *swig_obj[1] ;
10506
10507 if (!args) SWIG_fail;
10508 swig_obj[0] = args;
10509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10510 if (!SWIG_IsOK(res1)) {
10511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10512 }
10513 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10514 {
10515 PyThreadState* __tstate = wxPyBeginAllowThreads();
10516 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10517 wxPyEndAllowThreads(__tstate);
10518 if (PyErr_Occurred()) SWIG_fail;
10519 }
10520 resultobj = SWIG_From_int(static_cast< int >(result));
10521 return resultobj;
10522 fail:
10523 return NULL;
10524 }
10525
10526
10527 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10528 PyObject *resultobj = 0;
10529 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10530 wxPortId result;
10531 void *argp1 = 0 ;
10532 int res1 = 0 ;
10533 PyObject *swig_obj[1] ;
10534
10535 if (!args) SWIG_fail;
10536 swig_obj[0] = args;
10537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10538 if (!SWIG_IsOK(res1)) {
10539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10540 }
10541 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10542 {
10543 PyThreadState* __tstate = wxPyBeginAllowThreads();
10544 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10545 wxPyEndAllowThreads(__tstate);
10546 if (PyErr_Occurred()) SWIG_fail;
10547 }
10548 resultobj = SWIG_From_int(static_cast< int >(result));
10549 return resultobj;
10550 fail:
10551 return NULL;
10552 }
10553
10554
10555 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10556 PyObject *resultobj = 0;
10557 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10558 wxArchitecture result;
10559 void *argp1 = 0 ;
10560 int res1 = 0 ;
10561 PyObject *swig_obj[1] ;
10562
10563 if (!args) SWIG_fail;
10564 swig_obj[0] = args;
10565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10566 if (!SWIG_IsOK(res1)) {
10567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10568 }
10569 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10570 {
10571 PyThreadState* __tstate = wxPyBeginAllowThreads();
10572 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10573 wxPyEndAllowThreads(__tstate);
10574 if (PyErr_Occurred()) SWIG_fail;
10575 }
10576 resultobj = SWIG_From_int(static_cast< int >(result));
10577 return resultobj;
10578 fail:
10579 return NULL;
10580 }
10581
10582
10583 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10584 PyObject *resultobj = 0;
10585 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10586 wxEndianness result;
10587 void *argp1 = 0 ;
10588 int res1 = 0 ;
10589 PyObject *swig_obj[1] ;
10590
10591 if (!args) SWIG_fail;
10592 swig_obj[0] = args;
10593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10594 if (!SWIG_IsOK(res1)) {
10595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10596 }
10597 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10598 {
10599 PyThreadState* __tstate = wxPyBeginAllowThreads();
10600 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10601 wxPyEndAllowThreads(__tstate);
10602 if (PyErr_Occurred()) SWIG_fail;
10603 }
10604 resultobj = SWIG_From_int(static_cast< int >(result));
10605 return resultobj;
10606 fail:
10607 return NULL;
10608 }
10609
10610
10611 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10612 PyObject *resultobj = 0;
10613 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10614 wxString result;
10615 void *argp1 = 0 ;
10616 int res1 = 0 ;
10617 PyObject *swig_obj[1] ;
10618
10619 if (!args) SWIG_fail;
10620 swig_obj[0] = args;
10621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10622 if (!SWIG_IsOK(res1)) {
10623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10624 }
10625 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10626 {
10627 PyThreadState* __tstate = wxPyBeginAllowThreads();
10628 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10629 wxPyEndAllowThreads(__tstate);
10630 if (PyErr_Occurred()) SWIG_fail;
10631 }
10632 {
10633 #if wxUSE_UNICODE
10634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10635 #else
10636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10637 #endif
10638 }
10639 return resultobj;
10640 fail:
10641 return NULL;
10642 }
10643
10644
10645 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10646 PyObject *resultobj = 0;
10647 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10648 wxString result;
10649 void *argp1 = 0 ;
10650 int res1 = 0 ;
10651 PyObject *swig_obj[1] ;
10652
10653 if (!args) SWIG_fail;
10654 swig_obj[0] = args;
10655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10656 if (!SWIG_IsOK(res1)) {
10657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10658 }
10659 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10660 {
10661 PyThreadState* __tstate = wxPyBeginAllowThreads();
10662 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10663 wxPyEndAllowThreads(__tstate);
10664 if (PyErr_Occurred()) SWIG_fail;
10665 }
10666 {
10667 #if wxUSE_UNICODE
10668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10669 #else
10670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10671 #endif
10672 }
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10680 PyObject *resultobj = 0;
10681 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10682 wxString result;
10683 void *argp1 = 0 ;
10684 int res1 = 0 ;
10685 PyObject *swig_obj[1] ;
10686
10687 if (!args) SWIG_fail;
10688 swig_obj[0] = args;
10689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10690 if (!SWIG_IsOK(res1)) {
10691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10692 }
10693 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10694 {
10695 PyThreadState* __tstate = wxPyBeginAllowThreads();
10696 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10697 wxPyEndAllowThreads(__tstate);
10698 if (PyErr_Occurred()) SWIG_fail;
10699 }
10700 {
10701 #if wxUSE_UNICODE
10702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10703 #else
10704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10705 #endif
10706 }
10707 return resultobj;
10708 fail:
10709 return NULL;
10710 }
10711
10712
10713 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10714 PyObject *resultobj = 0;
10715 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10716 wxString result;
10717 void *argp1 = 0 ;
10718 int res1 = 0 ;
10719 PyObject *swig_obj[1] ;
10720
10721 if (!args) SWIG_fail;
10722 swig_obj[0] = args;
10723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10724 if (!SWIG_IsOK(res1)) {
10725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10726 }
10727 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10728 {
10729 PyThreadState* __tstate = wxPyBeginAllowThreads();
10730 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 {
10735 #if wxUSE_UNICODE
10736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10737 #else
10738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10739 #endif
10740 }
10741 return resultobj;
10742 fail:
10743 return NULL;
10744 }
10745
10746
10747 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10748 PyObject *resultobj = 0;
10749 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10750 wxString result;
10751 void *argp1 = 0 ;
10752 int res1 = 0 ;
10753 PyObject *swig_obj[1] ;
10754
10755 if (!args) SWIG_fail;
10756 swig_obj[0] = args;
10757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10758 if (!SWIG_IsOK(res1)) {
10759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10760 }
10761 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10762 {
10763 PyThreadState* __tstate = wxPyBeginAllowThreads();
10764 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10765 wxPyEndAllowThreads(__tstate);
10766 if (PyErr_Occurred()) SWIG_fail;
10767 }
10768 {
10769 #if wxUSE_UNICODE
10770 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10771 #else
10772 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10773 #endif
10774 }
10775 return resultobj;
10776 fail:
10777 return NULL;
10778 }
10779
10780
10781 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10782 PyObject *resultobj = 0;
10783 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10784 wxString result;
10785 void *argp1 = 0 ;
10786 int res1 = 0 ;
10787 PyObject *swig_obj[1] ;
10788
10789 if (!args) SWIG_fail;
10790 swig_obj[0] = args;
10791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10792 if (!SWIG_IsOK(res1)) {
10793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10794 }
10795 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10796 {
10797 PyThreadState* __tstate = wxPyBeginAllowThreads();
10798 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10799 wxPyEndAllowThreads(__tstate);
10800 if (PyErr_Occurred()) SWIG_fail;
10801 }
10802 {
10803 #if wxUSE_UNICODE
10804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10805 #else
10806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10807 #endif
10808 }
10809 return resultobj;
10810 fail:
10811 return NULL;
10812 }
10813
10814
10815 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10816 PyObject *resultobj = 0;
10817 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10818 int arg2 ;
10819 int arg3 ;
10820 void *argp1 = 0 ;
10821 int res1 = 0 ;
10822 int val2 ;
10823 int ecode2 = 0 ;
10824 int val3 ;
10825 int ecode3 = 0 ;
10826 PyObject * obj0 = 0 ;
10827 PyObject * obj1 = 0 ;
10828 PyObject * obj2 = 0 ;
10829 char * kwnames[] = {
10830 (char *) "self",(char *) "major",(char *) "minor", NULL
10831 };
10832
10833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10835 if (!SWIG_IsOK(res1)) {
10836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10837 }
10838 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10839 ecode2 = SWIG_AsVal_int(obj1, &val2);
10840 if (!SWIG_IsOK(ecode2)) {
10841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10842 }
10843 arg2 = static_cast< int >(val2);
10844 ecode3 = SWIG_AsVal_int(obj2, &val3);
10845 if (!SWIG_IsOK(ecode3)) {
10846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10847 }
10848 arg3 = static_cast< int >(val3);
10849 {
10850 PyThreadState* __tstate = wxPyBeginAllowThreads();
10851 (arg1)->SetOSVersion(arg2,arg3);
10852 wxPyEndAllowThreads(__tstate);
10853 if (PyErr_Occurred()) SWIG_fail;
10854 }
10855 resultobj = SWIG_Py_Void();
10856 return resultobj;
10857 fail:
10858 return NULL;
10859 }
10860
10861
10862 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10863 PyObject *resultobj = 0;
10864 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10865 int arg2 ;
10866 int arg3 ;
10867 void *argp1 = 0 ;
10868 int res1 = 0 ;
10869 int val2 ;
10870 int ecode2 = 0 ;
10871 int val3 ;
10872 int ecode3 = 0 ;
10873 PyObject * obj0 = 0 ;
10874 PyObject * obj1 = 0 ;
10875 PyObject * obj2 = 0 ;
10876 char * kwnames[] = {
10877 (char *) "self",(char *) "major",(char *) "minor", NULL
10878 };
10879
10880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) 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_SetToolkitVersion" "', 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_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10889 }
10890 arg2 = static_cast< int >(val2);
10891 ecode3 = SWIG_AsVal_int(obj2, &val3);
10892 if (!SWIG_IsOK(ecode3)) {
10893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10894 }
10895 arg3 = static_cast< int >(val3);
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 (arg1)->SetToolkitVersion(arg2,arg3);
10899 wxPyEndAllowThreads(__tstate);
10900 if (PyErr_Occurred()) SWIG_fail;
10901 }
10902 resultobj = SWIG_Py_Void();
10903 return resultobj;
10904 fail:
10905 return NULL;
10906 }
10907
10908
10909 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10910 PyObject *resultobj = 0;
10911 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10912 wxOperatingSystemId arg2 ;
10913 void *argp1 = 0 ;
10914 int res1 = 0 ;
10915 int val2 ;
10916 int ecode2 = 0 ;
10917 PyObject * obj0 = 0 ;
10918 PyObject * obj1 = 0 ;
10919 char * kwnames[] = {
10920 (char *) "self",(char *) "n", NULL
10921 };
10922
10923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10925 if (!SWIG_IsOK(res1)) {
10926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10927 }
10928 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10929 ecode2 = SWIG_AsVal_int(obj1, &val2);
10930 if (!SWIG_IsOK(ecode2)) {
10931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10932 }
10933 arg2 = static_cast< wxOperatingSystemId >(val2);
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 (arg1)->SetOperatingSystemId(arg2);
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 resultobj = SWIG_Py_Void();
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = 0;
10949 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10950 wxPortId arg2 ;
10951 void *argp1 = 0 ;
10952 int res1 = 0 ;
10953 int val2 ;
10954 int ecode2 = 0 ;
10955 PyObject * obj0 = 0 ;
10956 PyObject * obj1 = 0 ;
10957 char * kwnames[] = {
10958 (char *) "self",(char *) "n", NULL
10959 };
10960
10961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10963 if (!SWIG_IsOK(res1)) {
10964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10965 }
10966 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10967 ecode2 = SWIG_AsVal_int(obj1, &val2);
10968 if (!SWIG_IsOK(ecode2)) {
10969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10970 }
10971 arg2 = static_cast< wxPortId >(val2);
10972 {
10973 PyThreadState* __tstate = wxPyBeginAllowThreads();
10974 (arg1)->SetPortId(arg2);
10975 wxPyEndAllowThreads(__tstate);
10976 if (PyErr_Occurred()) SWIG_fail;
10977 }
10978 resultobj = SWIG_Py_Void();
10979 return resultobj;
10980 fail:
10981 return NULL;
10982 }
10983
10984
10985 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10986 PyObject *resultobj = 0;
10987 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10988 wxArchitecture arg2 ;
10989 void *argp1 = 0 ;
10990 int res1 = 0 ;
10991 int val2 ;
10992 int ecode2 = 0 ;
10993 PyObject * obj0 = 0 ;
10994 PyObject * obj1 = 0 ;
10995 char * kwnames[] = {
10996 (char *) "self",(char *) "n", NULL
10997 };
10998
10999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
11000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11001 if (!SWIG_IsOK(res1)) {
11002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11003 }
11004 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11005 ecode2 = SWIG_AsVal_int(obj1, &val2);
11006 if (!SWIG_IsOK(ecode2)) {
11007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11008 }
11009 arg2 = static_cast< wxArchitecture >(val2);
11010 {
11011 PyThreadState* __tstate = wxPyBeginAllowThreads();
11012 (arg1)->SetArchitecture(arg2);
11013 wxPyEndAllowThreads(__tstate);
11014 if (PyErr_Occurred()) SWIG_fail;
11015 }
11016 resultobj = SWIG_Py_Void();
11017 return resultobj;
11018 fail:
11019 return NULL;
11020 }
11021
11022
11023 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11024 PyObject *resultobj = 0;
11025 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11026 wxEndianness arg2 ;
11027 void *argp1 = 0 ;
11028 int res1 = 0 ;
11029 int val2 ;
11030 int ecode2 = 0 ;
11031 PyObject * obj0 = 0 ;
11032 PyObject * obj1 = 0 ;
11033 char * kwnames[] = {
11034 (char *) "self",(char *) "n", NULL
11035 };
11036
11037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11039 if (!SWIG_IsOK(res1)) {
11040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11041 }
11042 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11043 ecode2 = SWIG_AsVal_int(obj1, &val2);
11044 if (!SWIG_IsOK(ecode2)) {
11045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11046 }
11047 arg2 = static_cast< wxEndianness >(val2);
11048 {
11049 PyThreadState* __tstate = wxPyBeginAllowThreads();
11050 (arg1)->SetEndianness(arg2);
11051 wxPyEndAllowThreads(__tstate);
11052 if (PyErr_Occurred()) SWIG_fail;
11053 }
11054 resultobj = SWIG_Py_Void();
11055 return resultobj;
11056 fail:
11057 return NULL;
11058 }
11059
11060
11061 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11062 PyObject *resultobj = 0;
11063 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11064 bool result;
11065 void *argp1 = 0 ;
11066 int res1 = 0 ;
11067 PyObject *swig_obj[1] ;
11068
11069 if (!args) SWIG_fail;
11070 swig_obj[0] = args;
11071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11072 if (!SWIG_IsOK(res1)) {
11073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11074 }
11075 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11079 wxPyEndAllowThreads(__tstate);
11080 if (PyErr_Occurred()) SWIG_fail;
11081 }
11082 {
11083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11084 }
11085 return resultobj;
11086 fail:
11087 return NULL;
11088 }
11089
11090
11091 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11092 PyObject *obj;
11093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11094 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11095 return SWIG_Py_Void();
11096 }
11097
11098 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11099 return SWIG_Python_InitShadowInstance(args);
11100 }
11101
11102 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11103 PyObject *resultobj = 0;
11104 wxWindow *arg1 = (wxWindow *) 0 ;
11105 wxDC *arg2 = 0 ;
11106 bool result;
11107 void *argp1 = 0 ;
11108 int res1 = 0 ;
11109 void *argp2 = 0 ;
11110 int res2 = 0 ;
11111 PyObject * obj0 = 0 ;
11112 PyObject * obj1 = 0 ;
11113 char * kwnames[] = {
11114 (char *) "window",(char *) "dc", NULL
11115 };
11116
11117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11119 if (!SWIG_IsOK(res1)) {
11120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11121 }
11122 arg1 = reinterpret_cast< wxWindow * >(argp1);
11123 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11124 if (!SWIG_IsOK(res2)) {
11125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11126 }
11127 if (!argp2) {
11128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11129 }
11130 arg2 = reinterpret_cast< wxDC * >(argp2);
11131 {
11132 PyThreadState* __tstate = wxPyBeginAllowThreads();
11133 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11134 wxPyEndAllowThreads(__tstate);
11135 if (PyErr_Occurred()) SWIG_fail;
11136 }
11137 {
11138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11139 }
11140 return resultobj;
11141 fail:
11142 return NULL;
11143 }
11144
11145
11146 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11147 PyObject *resultobj = 0;
11148 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11149 void *argp1 = 0 ;
11150 int res1 = 0 ;
11151 PyObject *swig_obj[1] ;
11152
11153 if (!args) SWIG_fail;
11154 swig_obj[0] = args;
11155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11156 if (!SWIG_IsOK(res1)) {
11157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11158 }
11159 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11160 {
11161 PyThreadState* __tstate = wxPyBeginAllowThreads();
11162 delete arg1;
11163
11164 wxPyEndAllowThreads(__tstate);
11165 if (PyErr_Occurred()) SWIG_fail;
11166 }
11167 resultobj = SWIG_Py_Void();
11168 return resultobj;
11169 fail:
11170 return NULL;
11171 }
11172
11173
11174 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11175 PyObject *resultobj = 0;
11176 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11177 wxString result;
11178 void *argp1 = 0 ;
11179 int res1 = 0 ;
11180 PyObject *swig_obj[1] ;
11181
11182 if (!args) SWIG_fail;
11183 swig_obj[0] = args;
11184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11185 if (!SWIG_IsOK(res1)) {
11186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11187 }
11188 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11189 {
11190 PyThreadState* __tstate = wxPyBeginAllowThreads();
11191 result = (arg1)->GetTip();
11192 wxPyEndAllowThreads(__tstate);
11193 if (PyErr_Occurred()) SWIG_fail;
11194 }
11195 {
11196 #if wxUSE_UNICODE
11197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11198 #else
11199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11200 #endif
11201 }
11202 return resultobj;
11203 fail:
11204 return NULL;
11205 }
11206
11207
11208 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11209 PyObject *resultobj = 0;
11210 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11211 size_t result;
11212 void *argp1 = 0 ;
11213 int res1 = 0 ;
11214 PyObject *swig_obj[1] ;
11215
11216 if (!args) SWIG_fail;
11217 swig_obj[0] = args;
11218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11219 if (!SWIG_IsOK(res1)) {
11220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11221 }
11222 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11223 {
11224 PyThreadState* __tstate = wxPyBeginAllowThreads();
11225 result = (size_t)(arg1)->GetCurrentTip();
11226 wxPyEndAllowThreads(__tstate);
11227 if (PyErr_Occurred()) SWIG_fail;
11228 }
11229 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11230 return resultobj;
11231 fail:
11232 return NULL;
11233 }
11234
11235
11236 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11237 PyObject *resultobj = 0;
11238 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11239 wxString *arg2 = 0 ;
11240 wxString result;
11241 void *argp1 = 0 ;
11242 int res1 = 0 ;
11243 bool temp2 = false ;
11244 PyObject * obj0 = 0 ;
11245 PyObject * obj1 = 0 ;
11246 char * kwnames[] = {
11247 (char *) "self",(char *) "tip", NULL
11248 };
11249
11250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11252 if (!SWIG_IsOK(res1)) {
11253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11254 }
11255 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11256 {
11257 arg2 = wxString_in_helper(obj1);
11258 if (arg2 == NULL) SWIG_fail;
11259 temp2 = true;
11260 }
11261 {
11262 PyThreadState* __tstate = wxPyBeginAllowThreads();
11263 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11264 wxPyEndAllowThreads(__tstate);
11265 if (PyErr_Occurred()) SWIG_fail;
11266 }
11267 {
11268 #if wxUSE_UNICODE
11269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11270 #else
11271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11272 #endif
11273 }
11274 {
11275 if (temp2)
11276 delete arg2;
11277 }
11278 return resultobj;
11279 fail:
11280 {
11281 if (temp2)
11282 delete arg2;
11283 }
11284 return NULL;
11285 }
11286
11287
11288 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11289 PyObject *obj;
11290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11291 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11292 return SWIG_Py_Void();
11293 }
11294
11295 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11296 PyObject *resultobj = 0;
11297 size_t arg1 ;
11298 wxPyTipProvider *result = 0 ;
11299 size_t val1 ;
11300 int ecode1 = 0 ;
11301 PyObject * obj0 = 0 ;
11302 char * kwnames[] = {
11303 (char *) "currentTip", NULL
11304 };
11305
11306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11307 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11308 if (!SWIG_IsOK(ecode1)) {
11309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11310 }
11311 arg1 = static_cast< size_t >(val1);
11312 {
11313 PyThreadState* __tstate = wxPyBeginAllowThreads();
11314 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11315 wxPyEndAllowThreads(__tstate);
11316 if (PyErr_Occurred()) SWIG_fail;
11317 }
11318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11319 return resultobj;
11320 fail:
11321 return NULL;
11322 }
11323
11324
11325 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11326 PyObject *resultobj = 0;
11327 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11328 PyObject *arg2 = (PyObject *) 0 ;
11329 PyObject *arg3 = (PyObject *) 0 ;
11330 void *argp1 = 0 ;
11331 int res1 = 0 ;
11332 PyObject * obj0 = 0 ;
11333 PyObject * obj1 = 0 ;
11334 PyObject * obj2 = 0 ;
11335 char * kwnames[] = {
11336 (char *) "self",(char *) "self",(char *) "_class", NULL
11337 };
11338
11339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11341 if (!SWIG_IsOK(res1)) {
11342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11343 }
11344 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11345 arg2 = obj1;
11346 arg3 = obj2;
11347 {
11348 PyThreadState* __tstate = wxPyBeginAllowThreads();
11349 (arg1)->_setCallbackInfo(arg2,arg3);
11350 wxPyEndAllowThreads(__tstate);
11351 if (PyErr_Occurred()) SWIG_fail;
11352 }
11353 resultobj = SWIG_Py_Void();
11354 return resultobj;
11355 fail:
11356 return NULL;
11357 }
11358
11359
11360 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11361 PyObject *obj;
11362 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11363 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11364 return SWIG_Py_Void();
11365 }
11366
11367 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11368 return SWIG_Python_InitShadowInstance(args);
11369 }
11370
11371 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11372 PyObject *resultobj = 0;
11373 wxWindow *arg1 = (wxWindow *) 0 ;
11374 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11375 bool arg3 = (bool) true ;
11376 bool result;
11377 void *argp1 = 0 ;
11378 int res1 = 0 ;
11379 void *argp2 = 0 ;
11380 int res2 = 0 ;
11381 bool val3 ;
11382 int ecode3 = 0 ;
11383 PyObject * obj0 = 0 ;
11384 PyObject * obj1 = 0 ;
11385 PyObject * obj2 = 0 ;
11386 char * kwnames[] = {
11387 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11388 };
11389
11390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11392 if (!SWIG_IsOK(res1)) {
11393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11394 }
11395 arg1 = reinterpret_cast< wxWindow * >(argp1);
11396 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11397 if (!SWIG_IsOK(res2)) {
11398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11399 }
11400 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11401 if (obj2) {
11402 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11403 if (!SWIG_IsOK(ecode3)) {
11404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11405 }
11406 arg3 = static_cast< bool >(val3);
11407 }
11408 {
11409 if (!wxPyCheckForApp()) SWIG_fail;
11410 PyThreadState* __tstate = wxPyBeginAllowThreads();
11411 result = (bool)wxShowTip(arg1,arg2,arg3);
11412 wxPyEndAllowThreads(__tstate);
11413 if (PyErr_Occurred()) SWIG_fail;
11414 }
11415 {
11416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11417 }
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11425 PyObject *resultobj = 0;
11426 wxString *arg1 = 0 ;
11427 size_t arg2 ;
11428 wxTipProvider *result = 0 ;
11429 bool temp1 = false ;
11430 size_t val2 ;
11431 int ecode2 = 0 ;
11432 PyObject * obj0 = 0 ;
11433 PyObject * obj1 = 0 ;
11434 char * kwnames[] = {
11435 (char *) "filename",(char *) "currentTip", NULL
11436 };
11437
11438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11439 {
11440 arg1 = wxString_in_helper(obj0);
11441 if (arg1 == NULL) SWIG_fail;
11442 temp1 = true;
11443 }
11444 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11445 if (!SWIG_IsOK(ecode2)) {
11446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11447 }
11448 arg2 = static_cast< size_t >(val2);
11449 {
11450 if (!wxPyCheckForApp()) SWIG_fail;
11451 PyThreadState* __tstate = wxPyBeginAllowThreads();
11452 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11453 wxPyEndAllowThreads(__tstate);
11454 if (PyErr_Occurred()) SWIG_fail;
11455 }
11456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11457 {
11458 if (temp1)
11459 delete arg1;
11460 }
11461 return resultobj;
11462 fail:
11463 {
11464 if (temp1)
11465 delete arg1;
11466 }
11467 return NULL;
11468 }
11469
11470
11471 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj = 0;
11473 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11474 int arg2 = (int) wxID_ANY ;
11475 wxPyTimer *result = 0 ;
11476 void *argp1 = 0 ;
11477 int res1 = 0 ;
11478 int val2 ;
11479 int ecode2 = 0 ;
11480 PyObject * obj0 = 0 ;
11481 PyObject * obj1 = 0 ;
11482 char * kwnames[] = {
11483 (char *) "owner",(char *) "id", NULL
11484 };
11485
11486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11487 if (obj0) {
11488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11489 if (!SWIG_IsOK(res1)) {
11490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11491 }
11492 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11493 }
11494 if (obj1) {
11495 ecode2 = SWIG_AsVal_int(obj1, &val2);
11496 if (!SWIG_IsOK(ecode2)) {
11497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11498 }
11499 arg2 = static_cast< int >(val2);
11500 }
11501 {
11502 if (!wxPyCheckForApp()) SWIG_fail;
11503 PyThreadState* __tstate = wxPyBeginAllowThreads();
11504 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11505 wxPyEndAllowThreads(__tstate);
11506 if (PyErr_Occurred()) SWIG_fail;
11507 }
11508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11509 return resultobj;
11510 fail:
11511 return NULL;
11512 }
11513
11514
11515 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11516 PyObject *resultobj = 0;
11517 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11518 void *argp1 = 0 ;
11519 int res1 = 0 ;
11520 PyObject *swig_obj[1] ;
11521
11522 if (!args) SWIG_fail;
11523 swig_obj[0] = args;
11524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11525 if (!SWIG_IsOK(res1)) {
11526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11527 }
11528 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11529 {
11530 PyThreadState* __tstate = wxPyBeginAllowThreads();
11531 delete arg1;
11532
11533 wxPyEndAllowThreads(__tstate);
11534 if (PyErr_Occurred()) SWIG_fail;
11535 }
11536 resultobj = SWIG_Py_Void();
11537 return resultobj;
11538 fail:
11539 return NULL;
11540 }
11541
11542
11543 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11544 PyObject *resultobj = 0;
11545 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11546 PyObject *arg2 = (PyObject *) 0 ;
11547 PyObject *arg3 = (PyObject *) 0 ;
11548 int arg4 = (int) 0 ;
11549 void *argp1 = 0 ;
11550 int res1 = 0 ;
11551 int val4 ;
11552 int ecode4 = 0 ;
11553 PyObject * obj0 = 0 ;
11554 PyObject * obj1 = 0 ;
11555 PyObject * obj2 = 0 ;
11556 PyObject * obj3 = 0 ;
11557 char * kwnames[] = {
11558 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11559 };
11560
11561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11563 if (!SWIG_IsOK(res1)) {
11564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11565 }
11566 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11567 arg2 = obj1;
11568 arg3 = obj2;
11569 if (obj3) {
11570 ecode4 = SWIG_AsVal_int(obj3, &val4);
11571 if (!SWIG_IsOK(ecode4)) {
11572 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11573 }
11574 arg4 = static_cast< int >(val4);
11575 }
11576 {
11577 PyThreadState* __tstate = wxPyBeginAllowThreads();
11578 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 resultobj = SWIG_Py_Void();
11583 return resultobj;
11584 fail:
11585 return NULL;
11586 }
11587
11588
11589 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11590 PyObject *resultobj = 0;
11591 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11592 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11593 int arg3 = (int) wxID_ANY ;
11594 void *argp1 = 0 ;
11595 int res1 = 0 ;
11596 void *argp2 = 0 ;
11597 int res2 = 0 ;
11598 int val3 ;
11599 int ecode3 = 0 ;
11600 PyObject * obj0 = 0 ;
11601 PyObject * obj1 = 0 ;
11602 PyObject * obj2 = 0 ;
11603 char * kwnames[] = {
11604 (char *) "self",(char *) "owner",(char *) "id", NULL
11605 };
11606
11607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11609 if (!SWIG_IsOK(res1)) {
11610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11611 }
11612 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11613 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11614 if (!SWIG_IsOK(res2)) {
11615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11616 }
11617 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11618 if (obj2) {
11619 ecode3 = SWIG_AsVal_int(obj2, &val3);
11620 if (!SWIG_IsOK(ecode3)) {
11621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11622 }
11623 arg3 = static_cast< int >(val3);
11624 }
11625 {
11626 PyThreadState* __tstate = wxPyBeginAllowThreads();
11627 (arg1)->SetOwner(arg2,arg3);
11628 wxPyEndAllowThreads(__tstate);
11629 if (PyErr_Occurred()) SWIG_fail;
11630 }
11631 resultobj = SWIG_Py_Void();
11632 return resultobj;
11633 fail:
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11639 PyObject *resultobj = 0;
11640 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11641 wxEvtHandler *result = 0 ;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 PyObject *swig_obj[1] ;
11645
11646 if (!args) SWIG_fail;
11647 swig_obj[0] = args;
11648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11651 }
11652 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (wxEvtHandler *)(arg1)->GetOwner();
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 {
11660 resultobj = wxPyMake_wxObject(result, 0);
11661 }
11662 return resultobj;
11663 fail:
11664 return NULL;
11665 }
11666
11667
11668 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11669 PyObject *resultobj = 0;
11670 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11671 int arg2 = (int) -1 ;
11672 bool arg3 = (bool) false ;
11673 bool result;
11674 void *argp1 = 0 ;
11675 int res1 = 0 ;
11676 int val2 ;
11677 int ecode2 = 0 ;
11678 bool val3 ;
11679 int ecode3 = 0 ;
11680 PyObject * obj0 = 0 ;
11681 PyObject * obj1 = 0 ;
11682 PyObject * obj2 = 0 ;
11683 char * kwnames[] = {
11684 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11685 };
11686
11687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11689 if (!SWIG_IsOK(res1)) {
11690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11691 }
11692 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11693 if (obj1) {
11694 ecode2 = SWIG_AsVal_int(obj1, &val2);
11695 if (!SWIG_IsOK(ecode2)) {
11696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11697 }
11698 arg2 = static_cast< int >(val2);
11699 }
11700 if (obj2) {
11701 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11702 if (!SWIG_IsOK(ecode3)) {
11703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11704 }
11705 arg3 = static_cast< bool >(val3);
11706 }
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (bool)(arg1)->Start(arg2,arg3);
11710 wxPyEndAllowThreads(__tstate);
11711 if (PyErr_Occurred()) SWIG_fail;
11712 }
11713 {
11714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11715 }
11716 return resultobj;
11717 fail:
11718 return NULL;
11719 }
11720
11721
11722 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *resultobj = 0;
11724 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11725 void *argp1 = 0 ;
11726 int res1 = 0 ;
11727 PyObject *swig_obj[1] ;
11728
11729 if (!args) SWIG_fail;
11730 swig_obj[0] = args;
11731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11732 if (!SWIG_IsOK(res1)) {
11733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11734 }
11735 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11736 {
11737 PyThreadState* __tstate = wxPyBeginAllowThreads();
11738 (arg1)->Stop();
11739 wxPyEndAllowThreads(__tstate);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 resultobj = SWIG_Py_Void();
11743 return resultobj;
11744 fail:
11745 return NULL;
11746 }
11747
11748
11749 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11750 PyObject *resultobj = 0;
11751 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11752 void *argp1 = 0 ;
11753 int res1 = 0 ;
11754 PyObject *swig_obj[1] ;
11755
11756 if (!args) SWIG_fail;
11757 swig_obj[0] = args;
11758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11759 if (!SWIG_IsOK(res1)) {
11760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11761 }
11762 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11763 {
11764 PyThreadState* __tstate = wxPyBeginAllowThreads();
11765 (arg1)->Notify();
11766 wxPyEndAllowThreads(__tstate);
11767 if (PyErr_Occurred()) SWIG_fail;
11768 }
11769 resultobj = SWIG_Py_Void();
11770 return resultobj;
11771 fail:
11772 return NULL;
11773 }
11774
11775
11776 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11777 PyObject *resultobj = 0;
11778 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11779 bool result;
11780 void *argp1 = 0 ;
11781 int res1 = 0 ;
11782 PyObject *swig_obj[1] ;
11783
11784 if (!args) SWIG_fail;
11785 swig_obj[0] = args;
11786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11787 if (!SWIG_IsOK(res1)) {
11788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11789 }
11790 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11791 {
11792 PyThreadState* __tstate = wxPyBeginAllowThreads();
11793 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11794 wxPyEndAllowThreads(__tstate);
11795 if (PyErr_Occurred()) SWIG_fail;
11796 }
11797 {
11798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11799 }
11800 return resultobj;
11801 fail:
11802 return NULL;
11803 }
11804
11805
11806 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11807 PyObject *resultobj = 0;
11808 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11809 int result;
11810 void *argp1 = 0 ;
11811 int res1 = 0 ;
11812 PyObject *swig_obj[1] ;
11813
11814 if (!args) SWIG_fail;
11815 swig_obj[0] = args;
11816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11817 if (!SWIG_IsOK(res1)) {
11818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11819 }
11820 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11824 wxPyEndAllowThreads(__tstate);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 resultobj = SWIG_From_int(static_cast< int >(result));
11828 return resultobj;
11829 fail:
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 PyObject *resultobj = 0;
11836 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11837 int result;
11838 void *argp1 = 0 ;
11839 int res1 = 0 ;
11840 PyObject *swig_obj[1] ;
11841
11842 if (!args) SWIG_fail;
11843 swig_obj[0] = args;
11844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11845 if (!SWIG_IsOK(res1)) {
11846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11847 }
11848 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = (int)((wxPyTimer const *)arg1)->GetId();
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 resultobj = SWIG_From_int(static_cast< int >(result));
11856 return resultobj;
11857 fail:
11858 return NULL;
11859 }
11860
11861
11862 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11863 PyObject *resultobj = 0;
11864 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11865 bool result;
11866 void *argp1 = 0 ;
11867 int res1 = 0 ;
11868 PyObject *swig_obj[1] ;
11869
11870 if (!args) SWIG_fail;
11871 swig_obj[0] = args;
11872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11873 if (!SWIG_IsOK(res1)) {
11874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11875 }
11876 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11877 {
11878 PyThreadState* __tstate = wxPyBeginAllowThreads();
11879 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11880 wxPyEndAllowThreads(__tstate);
11881 if (PyErr_Occurred()) SWIG_fail;
11882 }
11883 {
11884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11885 }
11886 return resultobj;
11887 fail:
11888 return NULL;
11889 }
11890
11891
11892 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11893 PyObject *obj;
11894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11895 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11896 return SWIG_Py_Void();
11897 }
11898
11899 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11900 return SWIG_Python_InitShadowInstance(args);
11901 }
11902
11903 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11904 PyObject *resultobj = 0;
11905 int arg1 = (int) 0 ;
11906 int arg2 = (int) 0 ;
11907 wxTimerEvent *result = 0 ;
11908 int val1 ;
11909 int ecode1 = 0 ;
11910 int val2 ;
11911 int ecode2 = 0 ;
11912 PyObject * obj0 = 0 ;
11913 PyObject * obj1 = 0 ;
11914 char * kwnames[] = {
11915 (char *) "timerid",(char *) "interval", NULL
11916 };
11917
11918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11919 if (obj0) {
11920 ecode1 = SWIG_AsVal_int(obj0, &val1);
11921 if (!SWIG_IsOK(ecode1)) {
11922 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11923 }
11924 arg1 = static_cast< int >(val1);
11925 }
11926 if (obj1) {
11927 ecode2 = SWIG_AsVal_int(obj1, &val2);
11928 if (!SWIG_IsOK(ecode2)) {
11929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11930 }
11931 arg2 = static_cast< int >(val2);
11932 }
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11936 wxPyEndAllowThreads(__tstate);
11937 if (PyErr_Occurred()) SWIG_fail;
11938 }
11939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11940 return resultobj;
11941 fail:
11942 return NULL;
11943 }
11944
11945
11946 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11947 PyObject *resultobj = 0;
11948 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11949 int result;
11950 void *argp1 = 0 ;
11951 int res1 = 0 ;
11952 PyObject *swig_obj[1] ;
11953
11954 if (!args) SWIG_fail;
11955 swig_obj[0] = args;
11956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11957 if (!SWIG_IsOK(res1)) {
11958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11959 }
11960 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11961 {
11962 PyThreadState* __tstate = wxPyBeginAllowThreads();
11963 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11964 wxPyEndAllowThreads(__tstate);
11965 if (PyErr_Occurred()) SWIG_fail;
11966 }
11967 resultobj = SWIG_From_int(static_cast< int >(result));
11968 return resultobj;
11969 fail:
11970 return NULL;
11971 }
11972
11973
11974 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11975 PyObject *obj;
11976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11977 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11978 return SWIG_Py_Void();
11979 }
11980
11981 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11982 return SWIG_Python_InitShadowInstance(args);
11983 }
11984
11985 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11986 PyObject *resultobj = 0;
11987 wxTimer *arg1 = 0 ;
11988 wxTimerRunner *result = 0 ;
11989 void *argp1 = 0 ;
11990 int res1 = 0 ;
11991
11992 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11994 if (!SWIG_IsOK(res1)) {
11995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11996 }
11997 if (!argp1) {
11998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11999 }
12000 arg1 = reinterpret_cast< wxTimer * >(argp1);
12001 {
12002 if (!wxPyCheckForApp()) SWIG_fail;
12003 PyThreadState* __tstate = wxPyBeginAllowThreads();
12004 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
12005 wxPyEndAllowThreads(__tstate);
12006 if (PyErr_Occurred()) SWIG_fail;
12007 }
12008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12009 return resultobj;
12010 fail:
12011 return NULL;
12012 }
12013
12014
12015 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12016 PyObject *resultobj = 0;
12017 wxTimer *arg1 = 0 ;
12018 int arg2 ;
12019 bool arg3 = (bool) false ;
12020 wxTimerRunner *result = 0 ;
12021 void *argp1 = 0 ;
12022 int res1 = 0 ;
12023 int val2 ;
12024 int ecode2 = 0 ;
12025 bool val3 ;
12026 int ecode3 = 0 ;
12027
12028 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12030 if (!SWIG_IsOK(res1)) {
12031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12032 }
12033 if (!argp1) {
12034 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12035 }
12036 arg1 = reinterpret_cast< wxTimer * >(argp1);
12037 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12038 if (!SWIG_IsOK(ecode2)) {
12039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12040 }
12041 arg2 = static_cast< int >(val2);
12042 if (swig_obj[2]) {
12043 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12044 if (!SWIG_IsOK(ecode3)) {
12045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12046 }
12047 arg3 = static_cast< bool >(val3);
12048 }
12049 {
12050 if (!wxPyCheckForApp()) SWIG_fail;
12051 PyThreadState* __tstate = wxPyBeginAllowThreads();
12052 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12053 wxPyEndAllowThreads(__tstate);
12054 if (PyErr_Occurred()) SWIG_fail;
12055 }
12056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12057 return resultobj;
12058 fail:
12059 return NULL;
12060 }
12061
12062
12063 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12064 int argc;
12065 PyObject *argv[4];
12066
12067 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12068 --argc;
12069 if (argc == 1) {
12070 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12071 }
12072 if ((argc >= 2) && (argc <= 3)) {
12073 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12074 }
12075
12076 fail:
12077 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12078 return NULL;
12079 }
12080
12081
12082 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12083 PyObject *resultobj = 0;
12084 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12085 void *argp1 = 0 ;
12086 int res1 = 0 ;
12087 PyObject *swig_obj[1] ;
12088
12089 if (!args) SWIG_fail;
12090 swig_obj[0] = args;
12091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12092 if (!SWIG_IsOK(res1)) {
12093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12094 }
12095 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12096 {
12097 PyThreadState* __tstate = wxPyBeginAllowThreads();
12098 delete arg1;
12099
12100 wxPyEndAllowThreads(__tstate);
12101 if (PyErr_Occurred()) SWIG_fail;
12102 }
12103 resultobj = SWIG_Py_Void();
12104 return resultobj;
12105 fail:
12106 return NULL;
12107 }
12108
12109
12110 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12111 PyObject *resultobj = 0;
12112 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12113 int arg2 ;
12114 bool arg3 = (bool) false ;
12115 void *argp1 = 0 ;
12116 int res1 = 0 ;
12117 int val2 ;
12118 int ecode2 = 0 ;
12119 bool val3 ;
12120 int ecode3 = 0 ;
12121 PyObject * obj0 = 0 ;
12122 PyObject * obj1 = 0 ;
12123 PyObject * obj2 = 0 ;
12124 char * kwnames[] = {
12125 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12126 };
12127
12128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12130 if (!SWIG_IsOK(res1)) {
12131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12132 }
12133 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12134 ecode2 = SWIG_AsVal_int(obj1, &val2);
12135 if (!SWIG_IsOK(ecode2)) {
12136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12137 }
12138 arg2 = static_cast< int >(val2);
12139 if (obj2) {
12140 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12141 if (!SWIG_IsOK(ecode3)) {
12142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12143 }
12144 arg3 = static_cast< bool >(val3);
12145 }
12146 {
12147 PyThreadState* __tstate = wxPyBeginAllowThreads();
12148 (arg1)->Start(arg2,arg3);
12149 wxPyEndAllowThreads(__tstate);
12150 if (PyErr_Occurred()) SWIG_fail;
12151 }
12152 resultobj = SWIG_Py_Void();
12153 return resultobj;
12154 fail:
12155 return NULL;
12156 }
12157
12158
12159 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12160 PyObject *obj;
12161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12162 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12163 return SWIG_Py_Void();
12164 }
12165
12166 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12167 return SWIG_Python_InitShadowInstance(args);
12168 }
12169
12170 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12171 PyObject *resultobj = 0;
12172 wxLog *result = 0 ;
12173
12174 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12175 {
12176 PyThreadState* __tstate = wxPyBeginAllowThreads();
12177 result = (wxLog *)new wxLog();
12178 wxPyEndAllowThreads(__tstate);
12179 if (PyErr_Occurred()) SWIG_fail;
12180 }
12181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12182 return resultobj;
12183 fail:
12184 return NULL;
12185 }
12186
12187
12188 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12189 PyObject *resultobj = 0;
12190 wxLog *arg1 = (wxLog *) 0 ;
12191 void *argp1 = 0 ;
12192 int res1 = 0 ;
12193 PyObject *swig_obj[1] ;
12194
12195 if (!args) SWIG_fail;
12196 swig_obj[0] = args;
12197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12198 if (!SWIG_IsOK(res1)) {
12199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12200 }
12201 arg1 = reinterpret_cast< wxLog * >(argp1);
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 delete arg1;
12205
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 resultobj = SWIG_Py_Void();
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12217 PyObject *resultobj = 0;
12218 bool result;
12219
12220 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12221 {
12222 PyThreadState* __tstate = wxPyBeginAllowThreads();
12223 result = (bool)wxLog::IsEnabled();
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 {
12228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12229 }
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12237 PyObject *resultobj = 0;
12238 bool arg1 = (bool) true ;
12239 bool result;
12240 bool val1 ;
12241 int ecode1 = 0 ;
12242 PyObject * obj0 = 0 ;
12243 char * kwnames[] = {
12244 (char *) "doIt", NULL
12245 };
12246
12247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12248 if (obj0) {
12249 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12250 if (!SWIG_IsOK(ecode1)) {
12251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12252 }
12253 arg1 = static_cast< bool >(val1);
12254 }
12255 {
12256 PyThreadState* __tstate = wxPyBeginAllowThreads();
12257 result = (bool)wxLog::EnableLogging(arg1);
12258 wxPyEndAllowThreads(__tstate);
12259 if (PyErr_Occurred()) SWIG_fail;
12260 }
12261 {
12262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12263 }
12264 return resultobj;
12265 fail:
12266 return NULL;
12267 }
12268
12269
12270 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12271 PyObject *resultobj = 0;
12272 wxLogLevel arg1 ;
12273 wxChar *arg2 = (wxChar *) 0 ;
12274 time_t arg3 ;
12275 unsigned long val1 ;
12276 int ecode1 = 0 ;
12277 void *argp2 = 0 ;
12278 int res2 = 0 ;
12279 unsigned int val3 ;
12280 int ecode3 = 0 ;
12281 PyObject * obj0 = 0 ;
12282 PyObject * obj1 = 0 ;
12283 PyObject * obj2 = 0 ;
12284 char * kwnames[] = {
12285 (char *) "level",(char *) "szString",(char *) "t", NULL
12286 };
12287
12288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12289 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12290 if (!SWIG_IsOK(ecode1)) {
12291 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12292 }
12293 arg1 = static_cast< wxLogLevel >(val1);
12294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12295 if (!SWIG_IsOK(res2)) {
12296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12297 }
12298 arg2 = reinterpret_cast< wxChar * >(argp2);
12299 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12300 if (!SWIG_IsOK(ecode3)) {
12301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12302 }
12303 arg3 = static_cast< time_t >(val3);
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12307 wxPyEndAllowThreads(__tstate);
12308 if (PyErr_Occurred()) SWIG_fail;
12309 }
12310 resultobj = SWIG_Py_Void();
12311 return resultobj;
12312 fail:
12313 return NULL;
12314 }
12315
12316
12317 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12318 PyObject *resultobj = 0;
12319 wxLog *arg1 = (wxLog *) 0 ;
12320 void *argp1 = 0 ;
12321 int res1 = 0 ;
12322 PyObject *swig_obj[1] ;
12323
12324 if (!args) SWIG_fail;
12325 swig_obj[0] = args;
12326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12327 if (!SWIG_IsOK(res1)) {
12328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12329 }
12330 arg1 = reinterpret_cast< wxLog * >(argp1);
12331 {
12332 PyThreadState* __tstate = wxPyBeginAllowThreads();
12333 (arg1)->Flush();
12334 wxPyEndAllowThreads(__tstate);
12335 if (PyErr_Occurred()) SWIG_fail;
12336 }
12337 resultobj = SWIG_Py_Void();
12338 return resultobj;
12339 fail:
12340 return NULL;
12341 }
12342
12343
12344 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12345 PyObject *resultobj = 0;
12346
12347 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12348 {
12349 PyThreadState* __tstate = wxPyBeginAllowThreads();
12350 wxLog::FlushActive();
12351 wxPyEndAllowThreads(__tstate);
12352 if (PyErr_Occurred()) SWIG_fail;
12353 }
12354 resultobj = SWIG_Py_Void();
12355 return resultobj;
12356 fail:
12357 return NULL;
12358 }
12359
12360
12361 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12362 PyObject *resultobj = 0;
12363 wxLog *result = 0 ;
12364
12365 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12366 {
12367 PyThreadState* __tstate = wxPyBeginAllowThreads();
12368 result = (wxLog *)wxLog::GetActiveTarget();
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj = 0;
12381 wxLog *arg1 = (wxLog *) 0 ;
12382 wxLog *result = 0 ;
12383 int res1 = 0 ;
12384 PyObject * obj0 = 0 ;
12385 char * kwnames[] = {
12386 (char *) "pLogger", NULL
12387 };
12388
12389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12390 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12391 if (!SWIG_IsOK(res1)) {
12392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12393 }
12394 {
12395 PyThreadState* __tstate = wxPyBeginAllowThreads();
12396 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12397 wxPyEndAllowThreads(__tstate);
12398 if (PyErr_Occurred()) SWIG_fail;
12399 }
12400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12401 return resultobj;
12402 fail:
12403 return NULL;
12404 }
12405
12406
12407 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12408 PyObject *resultobj = 0;
12409
12410 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12411 {
12412 PyThreadState* __tstate = wxPyBeginAllowThreads();
12413 wxLog::Suspend();
12414 wxPyEndAllowThreads(__tstate);
12415 if (PyErr_Occurred()) SWIG_fail;
12416 }
12417 resultobj = SWIG_Py_Void();
12418 return resultobj;
12419 fail:
12420 return NULL;
12421 }
12422
12423
12424 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12425 PyObject *resultobj = 0;
12426
12427 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12428 {
12429 PyThreadState* __tstate = wxPyBeginAllowThreads();
12430 wxLog::Resume();
12431 wxPyEndAllowThreads(__tstate);
12432 if (PyErr_Occurred()) SWIG_fail;
12433 }
12434 resultobj = SWIG_Py_Void();
12435 return resultobj;
12436 fail:
12437 return NULL;
12438 }
12439
12440
12441 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12442 PyObject *resultobj = 0;
12443 bool arg1 = (bool) true ;
12444 bool val1 ;
12445 int ecode1 = 0 ;
12446 PyObject * obj0 = 0 ;
12447 char * kwnames[] = {
12448 (char *) "bVerbose", NULL
12449 };
12450
12451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12452 if (obj0) {
12453 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12454 if (!SWIG_IsOK(ecode1)) {
12455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12456 }
12457 arg1 = static_cast< bool >(val1);
12458 }
12459 {
12460 PyThreadState* __tstate = wxPyBeginAllowThreads();
12461 wxLog::SetVerbose(arg1);
12462 wxPyEndAllowThreads(__tstate);
12463 if (PyErr_Occurred()) SWIG_fail;
12464 }
12465 resultobj = SWIG_Py_Void();
12466 return resultobj;
12467 fail:
12468 return NULL;
12469 }
12470
12471
12472 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12473 PyObject *resultobj = 0;
12474 wxLogLevel arg1 ;
12475 unsigned long val1 ;
12476 int ecode1 = 0 ;
12477 PyObject * obj0 = 0 ;
12478 char * kwnames[] = {
12479 (char *) "logLevel", NULL
12480 };
12481
12482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12483 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12484 if (!SWIG_IsOK(ecode1)) {
12485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12486 }
12487 arg1 = static_cast< wxLogLevel >(val1);
12488 {
12489 PyThreadState* __tstate = wxPyBeginAllowThreads();
12490 wxLog::SetLogLevel(arg1);
12491 wxPyEndAllowThreads(__tstate);
12492 if (PyErr_Occurred()) SWIG_fail;
12493 }
12494 resultobj = SWIG_Py_Void();
12495 return resultobj;
12496 fail:
12497 return NULL;
12498 }
12499
12500
12501 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12502 PyObject *resultobj = 0;
12503
12504 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12505 {
12506 PyThreadState* __tstate = wxPyBeginAllowThreads();
12507 wxLog::DontCreateOnDemand();
12508 wxPyEndAllowThreads(__tstate);
12509 if (PyErr_Occurred()) SWIG_fail;
12510 }
12511 resultobj = SWIG_Py_Void();
12512 return resultobj;
12513 fail:
12514 return NULL;
12515 }
12516
12517
12518 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj = 0;
12520 bool arg1 = (bool) true ;
12521 bool val1 ;
12522 int ecode1 = 0 ;
12523 PyObject * obj0 = 0 ;
12524 char * kwnames[] = {
12525 (char *) "bRepetCounting", NULL
12526 };
12527
12528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12529 if (obj0) {
12530 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12531 if (!SWIG_IsOK(ecode1)) {
12532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12533 }
12534 arg1 = static_cast< bool >(val1);
12535 }
12536 {
12537 PyThreadState* __tstate = wxPyBeginAllowThreads();
12538 wxLog::SetRepetitionCounting(arg1);
12539 wxPyEndAllowThreads(__tstate);
12540 if (PyErr_Occurred()) SWIG_fail;
12541 }
12542 resultobj = SWIG_Py_Void();
12543 return resultobj;
12544 fail:
12545 return NULL;
12546 }
12547
12548
12549 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12550 PyObject *resultobj = 0;
12551 bool result;
12552
12553 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12554 {
12555 PyThreadState* __tstate = wxPyBeginAllowThreads();
12556 result = (bool)wxLog::GetRepetitionCounting();
12557 wxPyEndAllowThreads(__tstate);
12558 if (PyErr_Occurred()) SWIG_fail;
12559 }
12560 {
12561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12562 }
12563 return resultobj;
12564 fail:
12565 return NULL;
12566 }
12567
12568
12569 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12570 PyObject *resultobj = 0;
12571 wxTraceMask arg1 ;
12572 unsigned long val1 ;
12573 int ecode1 = 0 ;
12574 PyObject * obj0 = 0 ;
12575 char * kwnames[] = {
12576 (char *) "ulMask", NULL
12577 };
12578
12579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12580 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12581 if (!SWIG_IsOK(ecode1)) {
12582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12583 }
12584 arg1 = static_cast< wxTraceMask >(val1);
12585 {
12586 PyThreadState* __tstate = wxPyBeginAllowThreads();
12587 wxLog::SetTraceMask(arg1);
12588 wxPyEndAllowThreads(__tstate);
12589 if (PyErr_Occurred()) SWIG_fail;
12590 }
12591 resultobj = SWIG_Py_Void();
12592 return resultobj;
12593 fail:
12594 return NULL;
12595 }
12596
12597
12598 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12599 PyObject *resultobj = 0;
12600 wxString *arg1 = 0 ;
12601 bool temp1 = false ;
12602 PyObject * obj0 = 0 ;
12603 char * kwnames[] = {
12604 (char *) "str", NULL
12605 };
12606
12607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12608 {
12609 arg1 = wxString_in_helper(obj0);
12610 if (arg1 == NULL) SWIG_fail;
12611 temp1 = true;
12612 }
12613 {
12614 PyThreadState* __tstate = wxPyBeginAllowThreads();
12615 wxLog::AddTraceMask((wxString const &)*arg1);
12616 wxPyEndAllowThreads(__tstate);
12617 if (PyErr_Occurred()) SWIG_fail;
12618 }
12619 resultobj = SWIG_Py_Void();
12620 {
12621 if (temp1)
12622 delete arg1;
12623 }
12624 return resultobj;
12625 fail:
12626 {
12627 if (temp1)
12628 delete arg1;
12629 }
12630 return NULL;
12631 }
12632
12633
12634 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12635 PyObject *resultobj = 0;
12636 wxString *arg1 = 0 ;
12637 bool temp1 = false ;
12638 PyObject * obj0 = 0 ;
12639 char * kwnames[] = {
12640 (char *) "str", NULL
12641 };
12642
12643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12644 {
12645 arg1 = wxString_in_helper(obj0);
12646 if (arg1 == NULL) SWIG_fail;
12647 temp1 = true;
12648 }
12649 {
12650 PyThreadState* __tstate = wxPyBeginAllowThreads();
12651 wxLog::RemoveTraceMask((wxString const &)*arg1);
12652 wxPyEndAllowThreads(__tstate);
12653 if (PyErr_Occurred()) SWIG_fail;
12654 }
12655 resultobj = SWIG_Py_Void();
12656 {
12657 if (temp1)
12658 delete arg1;
12659 }
12660 return resultobj;
12661 fail:
12662 {
12663 if (temp1)
12664 delete arg1;
12665 }
12666 return NULL;
12667 }
12668
12669
12670 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12671 PyObject *resultobj = 0;
12672
12673 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12674 {
12675 PyThreadState* __tstate = wxPyBeginAllowThreads();
12676 wxLog::ClearTraceMasks();
12677 wxPyEndAllowThreads(__tstate);
12678 if (PyErr_Occurred()) SWIG_fail;
12679 }
12680 resultobj = SWIG_Py_Void();
12681 return resultobj;
12682 fail:
12683 return NULL;
12684 }
12685
12686
12687 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12688 PyObject *resultobj = 0;
12689 wxArrayString *result = 0 ;
12690
12691 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12692 {
12693 PyThreadState* __tstate = wxPyBeginAllowThreads();
12694 {
12695 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12696 result = (wxArrayString *) &_result_ref;
12697 }
12698 wxPyEndAllowThreads(__tstate);
12699 if (PyErr_Occurred()) SWIG_fail;
12700 }
12701 {
12702 resultobj = wxArrayString2PyList_helper(*result);
12703 }
12704 return resultobj;
12705 fail:
12706 return NULL;
12707 }
12708
12709
12710 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12711 PyObject *resultobj = 0;
12712 wxChar *arg1 = (wxChar *) 0 ;
12713 void *argp1 = 0 ;
12714 int res1 = 0 ;
12715 PyObject * obj0 = 0 ;
12716 char * kwnames[] = {
12717 (char *) "ts", NULL
12718 };
12719
12720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12722 if (!SWIG_IsOK(res1)) {
12723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12724 }
12725 arg1 = reinterpret_cast< wxChar * >(argp1);
12726 {
12727 PyThreadState* __tstate = wxPyBeginAllowThreads();
12728 wxLog::SetTimestamp((wxChar const *)arg1);
12729 wxPyEndAllowThreads(__tstate);
12730 if (PyErr_Occurred()) SWIG_fail;
12731 }
12732 resultobj = SWIG_Py_Void();
12733 return resultobj;
12734 fail:
12735 return NULL;
12736 }
12737
12738
12739 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12740 PyObject *resultobj = 0;
12741 bool result;
12742
12743 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12744 {
12745 PyThreadState* __tstate = wxPyBeginAllowThreads();
12746 result = (bool)wxLog::GetVerbose();
12747 wxPyEndAllowThreads(__tstate);
12748 if (PyErr_Occurred()) SWIG_fail;
12749 }
12750 {
12751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12752 }
12753 return resultobj;
12754 fail:
12755 return NULL;
12756 }
12757
12758
12759 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12760 PyObject *resultobj = 0;
12761 wxTraceMask result;
12762
12763 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12764 {
12765 PyThreadState* __tstate = wxPyBeginAllowThreads();
12766 result = (wxTraceMask)wxLog::GetTraceMask();
12767 wxPyEndAllowThreads(__tstate);
12768 if (PyErr_Occurred()) SWIG_fail;
12769 }
12770 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12771 return resultobj;
12772 fail:
12773 return NULL;
12774 }
12775
12776
12777 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12778 PyObject *resultobj = 0;
12779 wxChar *arg1 = (wxChar *) 0 ;
12780 bool result;
12781 void *argp1 = 0 ;
12782 int res1 = 0 ;
12783 PyObject * obj0 = 0 ;
12784 char * kwnames[] = {
12785 (char *) "mask", NULL
12786 };
12787
12788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12790 if (!SWIG_IsOK(res1)) {
12791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12792 }
12793 arg1 = reinterpret_cast< wxChar * >(argp1);
12794 {
12795 PyThreadState* __tstate = wxPyBeginAllowThreads();
12796 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12797 wxPyEndAllowThreads(__tstate);
12798 if (PyErr_Occurred()) SWIG_fail;
12799 }
12800 {
12801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12802 }
12803 return resultobj;
12804 fail:
12805 return NULL;
12806 }
12807
12808
12809 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12810 PyObject *resultobj = 0;
12811 wxLogLevel result;
12812
12813 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12814 {
12815 PyThreadState* __tstate = wxPyBeginAllowThreads();
12816 result = (wxLogLevel)wxLog::GetLogLevel();
12817 wxPyEndAllowThreads(__tstate);
12818 if (PyErr_Occurred()) SWIG_fail;
12819 }
12820 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12828 PyObject *resultobj = 0;
12829 wxChar *result = 0 ;
12830
12831 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12832 {
12833 PyThreadState* __tstate = wxPyBeginAllowThreads();
12834 result = (wxChar *)wxLog::GetTimestamp();
12835 wxPyEndAllowThreads(__tstate);
12836 if (PyErr_Occurred()) SWIG_fail;
12837 }
12838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12839 return resultobj;
12840 fail:
12841 return NULL;
12842 }
12843
12844
12845 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12846 PyObject *resultobj = 0;
12847 wxString result;
12848
12849 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12850 {
12851 PyThreadState* __tstate = wxPyBeginAllowThreads();
12852 result = wxLog_TimeStamp();
12853 wxPyEndAllowThreads(__tstate);
12854 if (PyErr_Occurred()) SWIG_fail;
12855 }
12856 {
12857 #if wxUSE_UNICODE
12858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12859 #else
12860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12861 #endif
12862 }
12863 return resultobj;
12864 fail:
12865 return NULL;
12866 }
12867
12868
12869 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12870 PyObject *resultobj = 0;
12871 wxLog *arg1 = (wxLog *) 0 ;
12872 void *argp1 = 0 ;
12873 int res1 = 0 ;
12874 PyObject *swig_obj[1] ;
12875
12876 if (!args) SWIG_fail;
12877 swig_obj[0] = args;
12878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12879 if (!SWIG_IsOK(res1)) {
12880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12881 }
12882 arg1 = reinterpret_cast< wxLog * >(argp1);
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 wxLog_Destroy(arg1);
12886 wxPyEndAllowThreads(__tstate);
12887 if (PyErr_Occurred()) SWIG_fail;
12888 }
12889 resultobj = SWIG_Py_Void();
12890 return resultobj;
12891 fail:
12892 return NULL;
12893 }
12894
12895
12896 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12897 PyObject *obj;
12898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12899 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12900 return SWIG_Py_Void();
12901 }
12902
12903 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12904 return SWIG_Python_InitShadowInstance(args);
12905 }
12906
12907 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12908 PyObject *resultobj = 0;
12909 wxLogStderr *result = 0 ;
12910
12911 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12912 {
12913 PyThreadState* __tstate = wxPyBeginAllowThreads();
12914 result = (wxLogStderr *)new wxLogStderr();
12915 wxPyEndAllowThreads(__tstate);
12916 if (PyErr_Occurred()) SWIG_fail;
12917 }
12918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12919 return resultobj;
12920 fail:
12921 return NULL;
12922 }
12923
12924
12925 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12926 PyObject *obj;
12927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12928 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12929 return SWIG_Py_Void();
12930 }
12931
12932 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12933 return SWIG_Python_InitShadowInstance(args);
12934 }
12935
12936 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12937 PyObject *resultobj = 0;
12938 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12939 wxLogTextCtrl *result = 0 ;
12940 void *argp1 = 0 ;
12941 int res1 = 0 ;
12942 PyObject * obj0 = 0 ;
12943 char * kwnames[] = {
12944 (char *) "pTextCtrl", NULL
12945 };
12946
12947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12949 if (!SWIG_IsOK(res1)) {
12950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12951 }
12952 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12953 {
12954 PyThreadState* __tstate = wxPyBeginAllowThreads();
12955 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12956 wxPyEndAllowThreads(__tstate);
12957 if (PyErr_Occurred()) SWIG_fail;
12958 }
12959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12960 return resultobj;
12961 fail:
12962 return NULL;
12963 }
12964
12965
12966 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12967 PyObject *obj;
12968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12969 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12970 return SWIG_Py_Void();
12971 }
12972
12973 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12974 return SWIG_Python_InitShadowInstance(args);
12975 }
12976
12977 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12978 PyObject *resultobj = 0;
12979 wxLogGui *result = 0 ;
12980
12981 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12982 {
12983 PyThreadState* __tstate = wxPyBeginAllowThreads();
12984 result = (wxLogGui *)new wxLogGui();
12985 wxPyEndAllowThreads(__tstate);
12986 if (PyErr_Occurred()) SWIG_fail;
12987 }
12988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12989 return resultobj;
12990 fail:
12991 return NULL;
12992 }
12993
12994
12995 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12996 PyObject *obj;
12997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12998 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12999 return SWIG_Py_Void();
13000 }
13001
13002 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13003 return SWIG_Python_InitShadowInstance(args);
13004 }
13005
13006 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj = 0;
13008 wxFrame *arg1 = (wxFrame *) 0 ;
13009 wxString *arg2 = 0 ;
13010 bool arg3 = (bool) true ;
13011 bool arg4 = (bool) true ;
13012 wxLogWindow *result = 0 ;
13013 void *argp1 = 0 ;
13014 int res1 = 0 ;
13015 bool temp2 = false ;
13016 bool val3 ;
13017 int ecode3 = 0 ;
13018 bool val4 ;
13019 int ecode4 = 0 ;
13020 PyObject * obj0 = 0 ;
13021 PyObject * obj1 = 0 ;
13022 PyObject * obj2 = 0 ;
13023 PyObject * obj3 = 0 ;
13024 char * kwnames[] = {
13025 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13026 };
13027
13028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13030 if (!SWIG_IsOK(res1)) {
13031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13032 }
13033 arg1 = reinterpret_cast< wxFrame * >(argp1);
13034 {
13035 arg2 = wxString_in_helper(obj1);
13036 if (arg2 == NULL) SWIG_fail;
13037 temp2 = true;
13038 }
13039 if (obj2) {
13040 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13041 if (!SWIG_IsOK(ecode3)) {
13042 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13043 }
13044 arg3 = static_cast< bool >(val3);
13045 }
13046 if (obj3) {
13047 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13048 if (!SWIG_IsOK(ecode4)) {
13049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13050 }
13051 arg4 = static_cast< bool >(val4);
13052 }
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13056 wxPyEndAllowThreads(__tstate);
13057 if (PyErr_Occurred()) SWIG_fail;
13058 }
13059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13060 {
13061 if (temp2)
13062 delete arg2;
13063 }
13064 return resultobj;
13065 fail:
13066 {
13067 if (temp2)
13068 delete arg2;
13069 }
13070 return NULL;
13071 }
13072
13073
13074 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13075 PyObject *resultobj = 0;
13076 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13077 bool arg2 = (bool) true ;
13078 void *argp1 = 0 ;
13079 int res1 = 0 ;
13080 bool val2 ;
13081 int ecode2 = 0 ;
13082 PyObject * obj0 = 0 ;
13083 PyObject * obj1 = 0 ;
13084 char * kwnames[] = {
13085 (char *) "self",(char *) "bShow", NULL
13086 };
13087
13088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13090 if (!SWIG_IsOK(res1)) {
13091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13092 }
13093 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13094 if (obj1) {
13095 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13096 if (!SWIG_IsOK(ecode2)) {
13097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13098 }
13099 arg2 = static_cast< bool >(val2);
13100 }
13101 {
13102 PyThreadState* __tstate = wxPyBeginAllowThreads();
13103 (arg1)->Show(arg2);
13104 wxPyEndAllowThreads(__tstate);
13105 if (PyErr_Occurred()) SWIG_fail;
13106 }
13107 resultobj = SWIG_Py_Void();
13108 return resultobj;
13109 fail:
13110 return NULL;
13111 }
13112
13113
13114 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13115 PyObject *resultobj = 0;
13116 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13117 wxFrame *result = 0 ;
13118 void *argp1 = 0 ;
13119 int res1 = 0 ;
13120 PyObject *swig_obj[1] ;
13121
13122 if (!args) SWIG_fail;
13123 swig_obj[0] = args;
13124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13125 if (!SWIG_IsOK(res1)) {
13126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13127 }
13128 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13129 {
13130 PyThreadState* __tstate = wxPyBeginAllowThreads();
13131 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13132 wxPyEndAllowThreads(__tstate);
13133 if (PyErr_Occurred()) SWIG_fail;
13134 }
13135 {
13136 resultobj = wxPyMake_wxObject(result, (bool)0);
13137 }
13138 return resultobj;
13139 fail:
13140 return NULL;
13141 }
13142
13143
13144 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13145 PyObject *resultobj = 0;
13146 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13147 wxLog *result = 0 ;
13148 void *argp1 = 0 ;
13149 int res1 = 0 ;
13150 PyObject *swig_obj[1] ;
13151
13152 if (!args) SWIG_fail;
13153 swig_obj[0] = args;
13154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13155 if (!SWIG_IsOK(res1)) {
13156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13157 }
13158 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13159 {
13160 PyThreadState* __tstate = wxPyBeginAllowThreads();
13161 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13162 wxPyEndAllowThreads(__tstate);
13163 if (PyErr_Occurred()) SWIG_fail;
13164 }
13165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13166 return resultobj;
13167 fail:
13168 return NULL;
13169 }
13170
13171
13172 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13173 PyObject *resultobj = 0;
13174 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13175 bool result;
13176 void *argp1 = 0 ;
13177 int res1 = 0 ;
13178 PyObject *swig_obj[1] ;
13179
13180 if (!args) SWIG_fail;
13181 swig_obj[0] = args;
13182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13183 if (!SWIG_IsOK(res1)) {
13184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13185 }
13186 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13187 {
13188 PyThreadState* __tstate = wxPyBeginAllowThreads();
13189 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13190 wxPyEndAllowThreads(__tstate);
13191 if (PyErr_Occurred()) SWIG_fail;
13192 }
13193 {
13194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13195 }
13196 return resultobj;
13197 fail:
13198 return NULL;
13199 }
13200
13201
13202 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13203 PyObject *resultobj = 0;
13204 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13205 bool arg2 ;
13206 void *argp1 = 0 ;
13207 int res1 = 0 ;
13208 bool val2 ;
13209 int ecode2 = 0 ;
13210 PyObject * obj0 = 0 ;
13211 PyObject * obj1 = 0 ;
13212 char * kwnames[] = {
13213 (char *) "self",(char *) "bDoPass", NULL
13214 };
13215
13216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13218 if (!SWIG_IsOK(res1)) {
13219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13220 }
13221 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13222 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13223 if (!SWIG_IsOK(ecode2)) {
13224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13225 }
13226 arg2 = static_cast< bool >(val2);
13227 {
13228 PyThreadState* __tstate = wxPyBeginAllowThreads();
13229 (arg1)->PassMessages(arg2);
13230 wxPyEndAllowThreads(__tstate);
13231 if (PyErr_Occurred()) SWIG_fail;
13232 }
13233 resultobj = SWIG_Py_Void();
13234 return resultobj;
13235 fail:
13236 return NULL;
13237 }
13238
13239
13240 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13241 PyObject *obj;
13242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13243 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13244 return SWIG_Py_Void();
13245 }
13246
13247 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13248 return SWIG_Python_InitShadowInstance(args);
13249 }
13250
13251 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj = 0;
13253 wxLog *arg1 = (wxLog *) 0 ;
13254 wxLogChain *result = 0 ;
13255 void *argp1 = 0 ;
13256 int res1 = 0 ;
13257 PyObject * obj0 = 0 ;
13258 char * kwnames[] = {
13259 (char *) "logger", NULL
13260 };
13261
13262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13264 if (!SWIG_IsOK(res1)) {
13265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13266 }
13267 arg1 = reinterpret_cast< wxLog * >(argp1);
13268 {
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 result = (wxLogChain *)new wxLogChain(arg1);
13271 wxPyEndAllowThreads(__tstate);
13272 if (PyErr_Occurred()) SWIG_fail;
13273 }
13274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13275 return resultobj;
13276 fail:
13277 return NULL;
13278 }
13279
13280
13281 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13282 PyObject *resultobj = 0;
13283 wxLogChain *arg1 = (wxLogChain *) 0 ;
13284 wxLog *arg2 = (wxLog *) 0 ;
13285 void *argp1 = 0 ;
13286 int res1 = 0 ;
13287 void *argp2 = 0 ;
13288 int res2 = 0 ;
13289 PyObject * obj0 = 0 ;
13290 PyObject * obj1 = 0 ;
13291 char * kwnames[] = {
13292 (char *) "self",(char *) "logger", NULL
13293 };
13294
13295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13297 if (!SWIG_IsOK(res1)) {
13298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13299 }
13300 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13301 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13302 if (!SWIG_IsOK(res2)) {
13303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13304 }
13305 arg2 = reinterpret_cast< wxLog * >(argp2);
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 (arg1)->SetLog(arg2);
13309 wxPyEndAllowThreads(__tstate);
13310 if (PyErr_Occurred()) SWIG_fail;
13311 }
13312 resultobj = SWIG_Py_Void();
13313 return resultobj;
13314 fail:
13315 return NULL;
13316 }
13317
13318
13319 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13320 PyObject *resultobj = 0;
13321 wxLogChain *arg1 = (wxLogChain *) 0 ;
13322 bool arg2 ;
13323 void *argp1 = 0 ;
13324 int res1 = 0 ;
13325 bool val2 ;
13326 int ecode2 = 0 ;
13327 PyObject * obj0 = 0 ;
13328 PyObject * obj1 = 0 ;
13329 char * kwnames[] = {
13330 (char *) "self",(char *) "bDoPass", NULL
13331 };
13332
13333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13335 if (!SWIG_IsOK(res1)) {
13336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13337 }
13338 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13339 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13340 if (!SWIG_IsOK(ecode2)) {
13341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13342 }
13343 arg2 = static_cast< bool >(val2);
13344 {
13345 PyThreadState* __tstate = wxPyBeginAllowThreads();
13346 (arg1)->PassMessages(arg2);
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 resultobj = SWIG_Py_Void();
13351 return resultobj;
13352 fail:
13353 return NULL;
13354 }
13355
13356
13357 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13358 PyObject *resultobj = 0;
13359 wxLogChain *arg1 = (wxLogChain *) 0 ;
13360 bool result;
13361 void *argp1 = 0 ;
13362 int res1 = 0 ;
13363 PyObject *swig_obj[1] ;
13364
13365 if (!args) SWIG_fail;
13366 swig_obj[0] = args;
13367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13368 if (!SWIG_IsOK(res1)) {
13369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13370 }
13371 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13372 {
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 result = (bool)(arg1)->IsPassingMessages();
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 {
13379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13380 }
13381 return resultobj;
13382 fail:
13383 return NULL;
13384 }
13385
13386
13387 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13388 PyObject *resultobj = 0;
13389 wxLogChain *arg1 = (wxLogChain *) 0 ;
13390 wxLog *result = 0 ;
13391 void *argp1 = 0 ;
13392 int res1 = 0 ;
13393 PyObject *swig_obj[1] ;
13394
13395 if (!args) SWIG_fail;
13396 swig_obj[0] = args;
13397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13398 if (!SWIG_IsOK(res1)) {
13399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13400 }
13401 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13402 {
13403 PyThreadState* __tstate = wxPyBeginAllowThreads();
13404 result = (wxLog *)(arg1)->GetOldLog();
13405 wxPyEndAllowThreads(__tstate);
13406 if (PyErr_Occurred()) SWIG_fail;
13407 }
13408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13409 return resultobj;
13410 fail:
13411 return NULL;
13412 }
13413
13414
13415 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13416 PyObject *obj;
13417 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13418 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13419 return SWIG_Py_Void();
13420 }
13421
13422 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13423 return SWIG_Python_InitShadowInstance(args);
13424 }
13425
13426 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13427 PyObject *resultobj = 0;
13428 wxLogBuffer *result = 0 ;
13429
13430 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13431 {
13432 PyThreadState* __tstate = wxPyBeginAllowThreads();
13433 result = (wxLogBuffer *)new wxLogBuffer();
13434 wxPyEndAllowThreads(__tstate);
13435 if (PyErr_Occurred()) SWIG_fail;
13436 }
13437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13438 return resultobj;
13439 fail:
13440 return NULL;
13441 }
13442
13443
13444 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13445 PyObject *resultobj = 0;
13446 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13447 wxString *result = 0 ;
13448 void *argp1 = 0 ;
13449 int res1 = 0 ;
13450 PyObject *swig_obj[1] ;
13451
13452 if (!args) SWIG_fail;
13453 swig_obj[0] = args;
13454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13455 if (!SWIG_IsOK(res1)) {
13456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13457 }
13458 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13459 {
13460 PyThreadState* __tstate = wxPyBeginAllowThreads();
13461 {
13462 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13463 result = (wxString *) &_result_ref;
13464 }
13465 wxPyEndAllowThreads(__tstate);
13466 if (PyErr_Occurred()) SWIG_fail;
13467 }
13468 {
13469 #if wxUSE_UNICODE
13470 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13471 #else
13472 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13473 #endif
13474 }
13475 return resultobj;
13476 fail:
13477 return NULL;
13478 }
13479
13480
13481 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13482 PyObject *obj;
13483 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13484 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13485 return SWIG_Py_Void();
13486 }
13487
13488 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13489 return SWIG_Python_InitShadowInstance(args);
13490 }
13491
13492 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13493 PyObject *resultobj = 0;
13494 unsigned long result;
13495
13496 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 result = (unsigned long)wxSysErrorCode();
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13504 return resultobj;
13505 fail:
13506 return NULL;
13507 }
13508
13509
13510 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13511 PyObject *resultobj = 0;
13512 unsigned long arg1 = (unsigned long) 0 ;
13513 wxString result;
13514 unsigned long val1 ;
13515 int ecode1 = 0 ;
13516 PyObject * obj0 = 0 ;
13517 char * kwnames[] = {
13518 (char *) "nErrCode", NULL
13519 };
13520
13521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13522 if (obj0) {
13523 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13524 if (!SWIG_IsOK(ecode1)) {
13525 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13526 }
13527 arg1 = static_cast< unsigned long >(val1);
13528 }
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 result = wxSysErrorMsg(arg1);
13532 wxPyEndAllowThreads(__tstate);
13533 if (PyErr_Occurred()) SWIG_fail;
13534 }
13535 {
13536 #if wxUSE_UNICODE
13537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13538 #else
13539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13540 #endif
13541 }
13542 return resultobj;
13543 fail:
13544 return NULL;
13545 }
13546
13547
13548 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13549 PyObject *resultobj = 0;
13550 wxString *arg1 = 0 ;
13551 bool temp1 = false ;
13552 PyObject * obj0 = 0 ;
13553 char * kwnames[] = {
13554 (char *) "msg", NULL
13555 };
13556
13557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13558 {
13559 arg1 = wxString_in_helper(obj0);
13560 if (arg1 == NULL) SWIG_fail;
13561 temp1 = true;
13562 }
13563 {
13564 PyThreadState* __tstate = wxPyBeginAllowThreads();
13565 wxPyLogFatalError((wxString const &)*arg1);
13566 wxPyEndAllowThreads(__tstate);
13567 if (PyErr_Occurred()) SWIG_fail;
13568 }
13569 resultobj = SWIG_Py_Void();
13570 {
13571 if (temp1)
13572 delete arg1;
13573 }
13574 return resultobj;
13575 fail:
13576 {
13577 if (temp1)
13578 delete arg1;
13579 }
13580 return NULL;
13581 }
13582
13583
13584 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13585 PyObject *resultobj = 0;
13586 wxString *arg1 = 0 ;
13587 bool temp1 = false ;
13588 PyObject * obj0 = 0 ;
13589 char * kwnames[] = {
13590 (char *) "msg", NULL
13591 };
13592
13593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13594 {
13595 arg1 = wxString_in_helper(obj0);
13596 if (arg1 == NULL) SWIG_fail;
13597 temp1 = true;
13598 }
13599 {
13600 PyThreadState* __tstate = wxPyBeginAllowThreads();
13601 wxPyLogError((wxString const &)*arg1);
13602 wxPyEndAllowThreads(__tstate);
13603 if (PyErr_Occurred()) SWIG_fail;
13604 }
13605 resultobj = SWIG_Py_Void();
13606 {
13607 if (temp1)
13608 delete arg1;
13609 }
13610 return resultobj;
13611 fail:
13612 {
13613 if (temp1)
13614 delete arg1;
13615 }
13616 return NULL;
13617 }
13618
13619
13620 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13621 PyObject *resultobj = 0;
13622 wxString *arg1 = 0 ;
13623 bool temp1 = false ;
13624 PyObject * obj0 = 0 ;
13625 char * kwnames[] = {
13626 (char *) "msg", NULL
13627 };
13628
13629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13630 {
13631 arg1 = wxString_in_helper(obj0);
13632 if (arg1 == NULL) SWIG_fail;
13633 temp1 = true;
13634 }
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 wxPyLogWarning((wxString const &)*arg1);
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_Py_Void();
13642 {
13643 if (temp1)
13644 delete arg1;
13645 }
13646 return resultobj;
13647 fail:
13648 {
13649 if (temp1)
13650 delete arg1;
13651 }
13652 return NULL;
13653 }
13654
13655
13656 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13657 PyObject *resultobj = 0;
13658 wxString *arg1 = 0 ;
13659 bool temp1 = false ;
13660 PyObject * obj0 = 0 ;
13661 char * kwnames[] = {
13662 (char *) "msg", NULL
13663 };
13664
13665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13666 {
13667 arg1 = wxString_in_helper(obj0);
13668 if (arg1 == NULL) SWIG_fail;
13669 temp1 = true;
13670 }
13671 {
13672 PyThreadState* __tstate = wxPyBeginAllowThreads();
13673 wxPyLogMessage((wxString const &)*arg1);
13674 wxPyEndAllowThreads(__tstate);
13675 if (PyErr_Occurred()) SWIG_fail;
13676 }
13677 resultobj = SWIG_Py_Void();
13678 {
13679 if (temp1)
13680 delete arg1;
13681 }
13682 return resultobj;
13683 fail:
13684 {
13685 if (temp1)
13686 delete arg1;
13687 }
13688 return NULL;
13689 }
13690
13691
13692 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13693 PyObject *resultobj = 0;
13694 wxString *arg1 = 0 ;
13695 bool temp1 = false ;
13696 PyObject * obj0 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "msg", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13702 {
13703 arg1 = wxString_in_helper(obj0);
13704 if (arg1 == NULL) SWIG_fail;
13705 temp1 = true;
13706 }
13707 {
13708 PyThreadState* __tstate = wxPyBeginAllowThreads();
13709 wxPyLogInfo((wxString const &)*arg1);
13710 wxPyEndAllowThreads(__tstate);
13711 if (PyErr_Occurred()) SWIG_fail;
13712 }
13713 resultobj = SWIG_Py_Void();
13714 {
13715 if (temp1)
13716 delete arg1;
13717 }
13718 return resultobj;
13719 fail:
13720 {
13721 if (temp1)
13722 delete arg1;
13723 }
13724 return NULL;
13725 }
13726
13727
13728 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13729 PyObject *resultobj = 0;
13730 wxString *arg1 = 0 ;
13731 bool temp1 = false ;
13732 PyObject * obj0 = 0 ;
13733 char * kwnames[] = {
13734 (char *) "msg", NULL
13735 };
13736
13737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13738 {
13739 arg1 = wxString_in_helper(obj0);
13740 if (arg1 == NULL) SWIG_fail;
13741 temp1 = true;
13742 }
13743 {
13744 PyThreadState* __tstate = wxPyBeginAllowThreads();
13745 wxPyLogDebug((wxString const &)*arg1);
13746 wxPyEndAllowThreads(__tstate);
13747 if (PyErr_Occurred()) SWIG_fail;
13748 }
13749 resultobj = SWIG_Py_Void();
13750 {
13751 if (temp1)
13752 delete arg1;
13753 }
13754 return resultobj;
13755 fail:
13756 {
13757 if (temp1)
13758 delete arg1;
13759 }
13760 return NULL;
13761 }
13762
13763
13764 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13765 PyObject *resultobj = 0;
13766 wxString *arg1 = 0 ;
13767 bool temp1 = false ;
13768 PyObject * obj0 = 0 ;
13769 char * kwnames[] = {
13770 (char *) "msg", NULL
13771 };
13772
13773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13774 {
13775 arg1 = wxString_in_helper(obj0);
13776 if (arg1 == NULL) SWIG_fail;
13777 temp1 = true;
13778 }
13779 {
13780 PyThreadState* __tstate = wxPyBeginAllowThreads();
13781 wxPyLogVerbose((wxString const &)*arg1);
13782 wxPyEndAllowThreads(__tstate);
13783 if (PyErr_Occurred()) SWIG_fail;
13784 }
13785 resultobj = SWIG_Py_Void();
13786 {
13787 if (temp1)
13788 delete arg1;
13789 }
13790 return resultobj;
13791 fail:
13792 {
13793 if (temp1)
13794 delete arg1;
13795 }
13796 return NULL;
13797 }
13798
13799
13800 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13801 PyObject *resultobj = 0;
13802 wxString *arg1 = 0 ;
13803 bool temp1 = false ;
13804 PyObject * obj0 = 0 ;
13805 char * kwnames[] = {
13806 (char *) "msg", NULL
13807 };
13808
13809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13810 {
13811 arg1 = wxString_in_helper(obj0);
13812 if (arg1 == NULL) SWIG_fail;
13813 temp1 = true;
13814 }
13815 {
13816 PyThreadState* __tstate = wxPyBeginAllowThreads();
13817 wxPyLogStatus((wxString const &)*arg1);
13818 wxPyEndAllowThreads(__tstate);
13819 if (PyErr_Occurred()) SWIG_fail;
13820 }
13821 resultobj = SWIG_Py_Void();
13822 {
13823 if (temp1)
13824 delete arg1;
13825 }
13826 return resultobj;
13827 fail:
13828 {
13829 if (temp1)
13830 delete arg1;
13831 }
13832 return NULL;
13833 }
13834
13835
13836 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13837 PyObject *resultobj = 0;
13838 wxFrame *arg1 = (wxFrame *) 0 ;
13839 wxString *arg2 = 0 ;
13840 void *argp1 = 0 ;
13841 int res1 = 0 ;
13842 bool temp2 = false ;
13843 PyObject * obj0 = 0 ;
13844 PyObject * obj1 = 0 ;
13845 char * kwnames[] = {
13846 (char *) "pFrame",(char *) "msg", NULL
13847 };
13848
13849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13851 if (!SWIG_IsOK(res1)) {
13852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13853 }
13854 arg1 = reinterpret_cast< wxFrame * >(argp1);
13855 {
13856 arg2 = wxString_in_helper(obj1);
13857 if (arg2 == NULL) SWIG_fail;
13858 temp2 = true;
13859 }
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 resultobj = SWIG_Py_Void();
13867 {
13868 if (temp2)
13869 delete arg2;
13870 }
13871 return resultobj;
13872 fail:
13873 {
13874 if (temp2)
13875 delete arg2;
13876 }
13877 return NULL;
13878 }
13879
13880
13881 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13882 PyObject *resultobj = 0;
13883 wxString *arg1 = 0 ;
13884 bool temp1 = false ;
13885 PyObject * obj0 = 0 ;
13886 char * kwnames[] = {
13887 (char *) "msg", NULL
13888 };
13889
13890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13891 {
13892 arg1 = wxString_in_helper(obj0);
13893 if (arg1 == NULL) SWIG_fail;
13894 temp1 = true;
13895 }
13896 {
13897 PyThreadState* __tstate = wxPyBeginAllowThreads();
13898 wxPyLogSysError((wxString const &)*arg1);
13899 wxPyEndAllowThreads(__tstate);
13900 if (PyErr_Occurred()) SWIG_fail;
13901 }
13902 resultobj = SWIG_Py_Void();
13903 {
13904 if (temp1)
13905 delete arg1;
13906 }
13907 return resultobj;
13908 fail:
13909 {
13910 if (temp1)
13911 delete arg1;
13912 }
13913 return NULL;
13914 }
13915
13916
13917 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13918 PyObject *resultobj = 0;
13919 unsigned long arg1 ;
13920 wxString *arg2 = 0 ;
13921 unsigned long val1 ;
13922 int ecode1 = 0 ;
13923 bool temp2 = false ;
13924 PyObject * obj0 = 0 ;
13925 PyObject * obj1 = 0 ;
13926 char * kwnames[] = {
13927 (char *) "level",(char *) "msg", NULL
13928 };
13929
13930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13931 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13932 if (!SWIG_IsOK(ecode1)) {
13933 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13934 }
13935 arg1 = static_cast< unsigned long >(val1);
13936 {
13937 arg2 = wxString_in_helper(obj1);
13938 if (arg2 == NULL) SWIG_fail;
13939 temp2 = true;
13940 }
13941 {
13942 PyThreadState* __tstate = wxPyBeginAllowThreads();
13943 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13944 wxPyEndAllowThreads(__tstate);
13945 if (PyErr_Occurred()) SWIG_fail;
13946 }
13947 resultobj = SWIG_Py_Void();
13948 {
13949 if (temp2)
13950 delete arg2;
13951 }
13952 return resultobj;
13953 fail:
13954 {
13955 if (temp2)
13956 delete arg2;
13957 }
13958 return NULL;
13959 }
13960
13961
13962 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13963 PyObject *resultobj = 0;
13964 unsigned long arg1 ;
13965 wxString *arg2 = 0 ;
13966 unsigned long val1 ;
13967 int ecode1 = 0 ;
13968 bool temp2 = false ;
13969
13970 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13971 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13972 if (!SWIG_IsOK(ecode1)) {
13973 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13974 }
13975 arg1 = static_cast< unsigned long >(val1);
13976 {
13977 arg2 = wxString_in_helper(swig_obj[1]);
13978 if (arg2 == NULL) SWIG_fail;
13979 temp2 = true;
13980 }
13981 {
13982 PyThreadState* __tstate = wxPyBeginAllowThreads();
13983 wxPyLogTrace(arg1,(wxString const &)*arg2);
13984 wxPyEndAllowThreads(__tstate);
13985 if (PyErr_Occurred()) SWIG_fail;
13986 }
13987 resultobj = SWIG_Py_Void();
13988 {
13989 if (temp2)
13990 delete arg2;
13991 }
13992 return resultobj;
13993 fail:
13994 {
13995 if (temp2)
13996 delete arg2;
13997 }
13998 return NULL;
13999 }
14000
14001
14002 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14003 PyObject *resultobj = 0;
14004 wxString *arg1 = 0 ;
14005 wxString *arg2 = 0 ;
14006 bool temp1 = false ;
14007 bool temp2 = false ;
14008
14009 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14010 {
14011 arg1 = wxString_in_helper(swig_obj[0]);
14012 if (arg1 == NULL) SWIG_fail;
14013 temp1 = true;
14014 }
14015 {
14016 arg2 = wxString_in_helper(swig_obj[1]);
14017 if (arg2 == NULL) SWIG_fail;
14018 temp2 = true;
14019 }
14020 {
14021 PyThreadState* __tstate = wxPyBeginAllowThreads();
14022 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_Py_Void();
14027 {
14028 if (temp1)
14029 delete arg1;
14030 }
14031 {
14032 if (temp2)
14033 delete arg2;
14034 }
14035 return resultobj;
14036 fail:
14037 {
14038 if (temp1)
14039 delete arg1;
14040 }
14041 {
14042 if (temp2)
14043 delete arg2;
14044 }
14045 return NULL;
14046 }
14047
14048
14049 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14050 int argc;
14051 PyObject *argv[3];
14052
14053 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14054 --argc;
14055 if (argc == 2) {
14056 int _v = 0;
14057 {
14058 {
14059 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14060 }
14061 }
14062 if (!_v) goto check_1;
14063 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14064 }
14065 check_1:
14066
14067 if (argc == 2) {
14068 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14069 }
14070
14071 fail:
14072 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14073 return NULL;
14074 }
14075
14076
14077 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14078 PyObject *resultobj = 0;
14079 wxString *arg1 = 0 ;
14080 wxString *arg2 = 0 ;
14081 bool temp1 = false ;
14082 bool temp2 = false ;
14083 PyObject * obj0 = 0 ;
14084 PyObject * obj1 = 0 ;
14085 char * kwnames[] = {
14086 (char *) "title",(char *) "text", NULL
14087 };
14088
14089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14090 {
14091 arg1 = wxString_in_helper(obj0);
14092 if (arg1 == NULL) SWIG_fail;
14093 temp1 = true;
14094 }
14095 {
14096 arg2 = wxString_in_helper(obj1);
14097 if (arg2 == NULL) SWIG_fail;
14098 temp2 = true;
14099 }
14100 {
14101 PyThreadState* __tstate = wxPyBeginAllowThreads();
14102 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14103 wxPyEndAllowThreads(__tstate);
14104 if (PyErr_Occurred()) SWIG_fail;
14105 }
14106 resultobj = SWIG_Py_Void();
14107 {
14108 if (temp1)
14109 delete arg1;
14110 }
14111 {
14112 if (temp2)
14113 delete arg2;
14114 }
14115 return resultobj;
14116 fail:
14117 {
14118 if (temp1)
14119 delete arg1;
14120 }
14121 {
14122 if (temp2)
14123 delete arg2;
14124 }
14125 return NULL;
14126 }
14127
14128
14129 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14130 PyObject *resultobj = 0;
14131 wxLogNull *result = 0 ;
14132
14133 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14134 {
14135 PyThreadState* __tstate = wxPyBeginAllowThreads();
14136 result = (wxLogNull *)new wxLogNull();
14137 wxPyEndAllowThreads(__tstate);
14138 if (PyErr_Occurred()) SWIG_fail;
14139 }
14140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14141 return resultobj;
14142 fail:
14143 return NULL;
14144 }
14145
14146
14147 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14148 PyObject *resultobj = 0;
14149 wxLogNull *arg1 = (wxLogNull *) 0 ;
14150 void *argp1 = 0 ;
14151 int res1 = 0 ;
14152 PyObject *swig_obj[1] ;
14153
14154 if (!args) SWIG_fail;
14155 swig_obj[0] = args;
14156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14157 if (!SWIG_IsOK(res1)) {
14158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14159 }
14160 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14161 {
14162 PyThreadState* __tstate = wxPyBeginAllowThreads();
14163 delete arg1;
14164
14165 wxPyEndAllowThreads(__tstate);
14166 if (PyErr_Occurred()) SWIG_fail;
14167 }
14168 resultobj = SWIG_Py_Void();
14169 return resultobj;
14170 fail:
14171 return NULL;
14172 }
14173
14174
14175 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14176 PyObject *obj;
14177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14178 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14179 return SWIG_Py_Void();
14180 }
14181
14182 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14183 return SWIG_Python_InitShadowInstance(args);
14184 }
14185
14186 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14187 PyObject *resultobj = 0;
14188 wxPyLog *result = 0 ;
14189
14190 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14191 {
14192 PyThreadState* __tstate = wxPyBeginAllowThreads();
14193 result = (wxPyLog *)new wxPyLog();
14194 wxPyEndAllowThreads(__tstate);
14195 if (PyErr_Occurred()) SWIG_fail;
14196 }
14197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14198 return resultobj;
14199 fail:
14200 return NULL;
14201 }
14202
14203
14204 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14205 PyObject *resultobj = 0;
14206 wxPyLog *arg1 = (wxPyLog *) 0 ;
14207 PyObject *arg2 = (PyObject *) 0 ;
14208 PyObject *arg3 = (PyObject *) 0 ;
14209 void *argp1 = 0 ;
14210 int res1 = 0 ;
14211 PyObject * obj0 = 0 ;
14212 PyObject * obj1 = 0 ;
14213 PyObject * obj2 = 0 ;
14214 char * kwnames[] = {
14215 (char *) "self",(char *) "self",(char *) "_class", NULL
14216 };
14217
14218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14220 if (!SWIG_IsOK(res1)) {
14221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14222 }
14223 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14224 arg2 = obj1;
14225 arg3 = obj2;
14226 {
14227 PyThreadState* __tstate = wxPyBeginAllowThreads();
14228 (arg1)->_setCallbackInfo(arg2,arg3);
14229 wxPyEndAllowThreads(__tstate);
14230 if (PyErr_Occurred()) SWIG_fail;
14231 }
14232 resultobj = SWIG_Py_Void();
14233 return resultobj;
14234 fail:
14235 return NULL;
14236 }
14237
14238
14239 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14240 PyObject *obj;
14241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14242 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14243 return SWIG_Py_Void();
14244 }
14245
14246 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14247 return SWIG_Python_InitShadowInstance(args);
14248 }
14249
14250 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14251 PyObject *resultobj = 0;
14252 int arg1 ;
14253 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14254 int arg3 = (int) wxKILL_NOCHILDREN ;
14255 wxKillError result;
14256 int val1 ;
14257 int ecode1 = 0 ;
14258 int val2 ;
14259 int ecode2 = 0 ;
14260 int val3 ;
14261 int ecode3 = 0 ;
14262 PyObject * obj0 = 0 ;
14263 PyObject * obj1 = 0 ;
14264 PyObject * obj2 = 0 ;
14265 char * kwnames[] = {
14266 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14267 };
14268
14269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14270 ecode1 = SWIG_AsVal_int(obj0, &val1);
14271 if (!SWIG_IsOK(ecode1)) {
14272 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14273 }
14274 arg1 = static_cast< int >(val1);
14275 if (obj1) {
14276 ecode2 = SWIG_AsVal_int(obj1, &val2);
14277 if (!SWIG_IsOK(ecode2)) {
14278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14279 }
14280 arg2 = static_cast< wxSignal >(val2);
14281 }
14282 if (obj2) {
14283 ecode3 = SWIG_AsVal_int(obj2, &val3);
14284 if (!SWIG_IsOK(ecode3)) {
14285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14286 }
14287 arg3 = static_cast< int >(val3);
14288 }
14289 {
14290 PyThreadState* __tstate = wxPyBeginAllowThreads();
14291 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14292 wxPyEndAllowThreads(__tstate);
14293 if (PyErr_Occurred()) SWIG_fail;
14294 }
14295 resultobj = SWIG_From_int(static_cast< int >(result));
14296 return resultobj;
14297 fail:
14298 return NULL;
14299 }
14300
14301
14302 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14303 PyObject *resultobj = 0;
14304 int arg1 ;
14305 bool result;
14306 int val1 ;
14307 int ecode1 = 0 ;
14308 PyObject * obj0 = 0 ;
14309 char * kwnames[] = {
14310 (char *) "pid", NULL
14311 };
14312
14313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14314 ecode1 = SWIG_AsVal_int(obj0, &val1);
14315 if (!SWIG_IsOK(ecode1)) {
14316 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14317 }
14318 arg1 = static_cast< int >(val1);
14319 {
14320 PyThreadState* __tstate = wxPyBeginAllowThreads();
14321 result = (bool)wxPyProcess::Exists(arg1);
14322 wxPyEndAllowThreads(__tstate);
14323 if (PyErr_Occurred()) SWIG_fail;
14324 }
14325 {
14326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14327 }
14328 return resultobj;
14329 fail:
14330 return NULL;
14331 }
14332
14333
14334 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14335 PyObject *resultobj = 0;
14336 wxString *arg1 = 0 ;
14337 int arg2 = (int) wxEXEC_ASYNC ;
14338 wxPyProcess *result = 0 ;
14339 bool temp1 = false ;
14340 int val2 ;
14341 int ecode2 = 0 ;
14342 PyObject * obj0 = 0 ;
14343 PyObject * obj1 = 0 ;
14344 char * kwnames[] = {
14345 (char *) "cmd",(char *) "flags", NULL
14346 };
14347
14348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14349 {
14350 arg1 = wxString_in_helper(obj0);
14351 if (arg1 == NULL) SWIG_fail;
14352 temp1 = true;
14353 }
14354 if (obj1) {
14355 ecode2 = SWIG_AsVal_int(obj1, &val2);
14356 if (!SWIG_IsOK(ecode2)) {
14357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14358 }
14359 arg2 = static_cast< int >(val2);
14360 }
14361 {
14362 PyThreadState* __tstate = wxPyBeginAllowThreads();
14363 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14364 wxPyEndAllowThreads(__tstate);
14365 if (PyErr_Occurred()) SWIG_fail;
14366 }
14367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14368 {
14369 if (temp1)
14370 delete arg1;
14371 }
14372 return resultobj;
14373 fail:
14374 {
14375 if (temp1)
14376 delete arg1;
14377 }
14378 return NULL;
14379 }
14380
14381
14382 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14383 PyObject *resultobj = 0;
14384 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14385 int arg2 = (int) -1 ;
14386 wxPyProcess *result = 0 ;
14387 void *argp1 = 0 ;
14388 int res1 = 0 ;
14389 int val2 ;
14390 int ecode2 = 0 ;
14391 PyObject * obj0 = 0 ;
14392 PyObject * obj1 = 0 ;
14393 char * kwnames[] = {
14394 (char *) "parent",(char *) "id", NULL
14395 };
14396
14397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14398 if (obj0) {
14399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14400 if (!SWIG_IsOK(res1)) {
14401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14402 }
14403 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14404 }
14405 if (obj1) {
14406 ecode2 = SWIG_AsVal_int(obj1, &val2);
14407 if (!SWIG_IsOK(ecode2)) {
14408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14409 }
14410 arg2 = static_cast< int >(val2);
14411 }
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14419 return resultobj;
14420 fail:
14421 return NULL;
14422 }
14423
14424
14425 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14426 PyObject *resultobj = 0;
14427 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14428 void *argp1 = 0 ;
14429 int res1 = 0 ;
14430 PyObject *swig_obj[1] ;
14431
14432 if (!args) SWIG_fail;
14433 swig_obj[0] = args;
14434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14435 if (!SWIG_IsOK(res1)) {
14436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14437 }
14438 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 delete arg1;
14442
14443 wxPyEndAllowThreads(__tstate);
14444 if (PyErr_Occurred()) SWIG_fail;
14445 }
14446 resultobj = SWIG_Py_Void();
14447 return resultobj;
14448 fail:
14449 return NULL;
14450 }
14451
14452
14453 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14454 PyObject *resultobj = 0;
14455 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14456 PyObject *arg2 = (PyObject *) 0 ;
14457 PyObject *arg3 = (PyObject *) 0 ;
14458 void *argp1 = 0 ;
14459 int res1 = 0 ;
14460 PyObject * obj0 = 0 ;
14461 PyObject * obj1 = 0 ;
14462 PyObject * obj2 = 0 ;
14463 char * kwnames[] = {
14464 (char *) "self",(char *) "self",(char *) "_class", NULL
14465 };
14466
14467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14469 if (!SWIG_IsOK(res1)) {
14470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14471 }
14472 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14473 arg2 = obj1;
14474 arg3 = obj2;
14475 {
14476 PyThreadState* __tstate = wxPyBeginAllowThreads();
14477 (arg1)->_setCallbackInfo(arg2,arg3);
14478 wxPyEndAllowThreads(__tstate);
14479 if (PyErr_Occurred()) SWIG_fail;
14480 }
14481 resultobj = SWIG_Py_Void();
14482 return resultobj;
14483 fail:
14484 return NULL;
14485 }
14486
14487
14488 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14489 PyObject *resultobj = 0;
14490 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14491 long result;
14492 void *argp1 = 0 ;
14493 int res1 = 0 ;
14494 PyObject *swig_obj[1] ;
14495
14496 if (!args) SWIG_fail;
14497 swig_obj[0] = args;
14498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14499 if (!SWIG_IsOK(res1)) {
14500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14501 }
14502 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14503 {
14504 PyThreadState* __tstate = wxPyBeginAllowThreads();
14505 result = (long)((wxPyProcess const *)arg1)->GetPid();
14506 wxPyEndAllowThreads(__tstate);
14507 if (PyErr_Occurred()) SWIG_fail;
14508 }
14509 resultobj = SWIG_From_long(static_cast< long >(result));
14510 return resultobj;
14511 fail:
14512 return NULL;
14513 }
14514
14515
14516 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14517 PyObject *resultobj = 0;
14518 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14519 int arg2 ;
14520 int arg3 ;
14521 void *argp1 = 0 ;
14522 int res1 = 0 ;
14523 int val2 ;
14524 int ecode2 = 0 ;
14525 int val3 ;
14526 int ecode3 = 0 ;
14527 PyObject * obj0 = 0 ;
14528 PyObject * obj1 = 0 ;
14529 PyObject * obj2 = 0 ;
14530 char * kwnames[] = {
14531 (char *) "self",(char *) "pid",(char *) "status", NULL
14532 };
14533
14534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14536 if (!SWIG_IsOK(res1)) {
14537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14538 }
14539 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14540 ecode2 = SWIG_AsVal_int(obj1, &val2);
14541 if (!SWIG_IsOK(ecode2)) {
14542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14543 }
14544 arg2 = static_cast< int >(val2);
14545 ecode3 = SWIG_AsVal_int(obj2, &val3);
14546 if (!SWIG_IsOK(ecode3)) {
14547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14548 }
14549 arg3 = static_cast< int >(val3);
14550 {
14551 PyThreadState* __tstate = wxPyBeginAllowThreads();
14552 (arg1)->OnTerminate(arg2,arg3);
14553 wxPyEndAllowThreads(__tstate);
14554 if (PyErr_Occurred()) SWIG_fail;
14555 }
14556 resultobj = SWIG_Py_Void();
14557 return resultobj;
14558 fail:
14559 return NULL;
14560 }
14561
14562
14563 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14564 PyObject *resultobj = 0;
14565 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14566 void *argp1 = 0 ;
14567 int res1 = 0 ;
14568 PyObject *swig_obj[1] ;
14569
14570 if (!args) SWIG_fail;
14571 swig_obj[0] = args;
14572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14573 if (!SWIG_IsOK(res1)) {
14574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14575 }
14576 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14577 {
14578 PyThreadState* __tstate = wxPyBeginAllowThreads();
14579 (arg1)->Redirect();
14580 wxPyEndAllowThreads(__tstate);
14581 if (PyErr_Occurred()) SWIG_fail;
14582 }
14583 resultobj = SWIG_Py_Void();
14584 return resultobj;
14585 fail:
14586 return NULL;
14587 }
14588
14589
14590 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14591 PyObject *resultobj = 0;
14592 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14593 bool result;
14594 void *argp1 = 0 ;
14595 int res1 = 0 ;
14596 PyObject *swig_obj[1] ;
14597
14598 if (!args) SWIG_fail;
14599 swig_obj[0] = args;
14600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14601 if (!SWIG_IsOK(res1)) {
14602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14603 }
14604 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14605 {
14606 PyThreadState* __tstate = wxPyBeginAllowThreads();
14607 result = (bool)(arg1)->IsRedirected();
14608 wxPyEndAllowThreads(__tstate);
14609 if (PyErr_Occurred()) SWIG_fail;
14610 }
14611 {
14612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14613 }
14614 return resultobj;
14615 fail:
14616 return NULL;
14617 }
14618
14619
14620 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14621 PyObject *resultobj = 0;
14622 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14623 void *argp1 = 0 ;
14624 int res1 = 0 ;
14625 PyObject *swig_obj[1] ;
14626
14627 if (!args) SWIG_fail;
14628 swig_obj[0] = args;
14629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14630 if (!SWIG_IsOK(res1)) {
14631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14632 }
14633 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14634 {
14635 PyThreadState* __tstate = wxPyBeginAllowThreads();
14636 (arg1)->Detach();
14637 wxPyEndAllowThreads(__tstate);
14638 if (PyErr_Occurred()) SWIG_fail;
14639 }
14640 resultobj = SWIG_Py_Void();
14641 return resultobj;
14642 fail:
14643 return NULL;
14644 }
14645
14646
14647 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14648 PyObject *resultobj = 0;
14649 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14650 wxInputStream *result = 0 ;
14651 void *argp1 = 0 ;
14652 int res1 = 0 ;
14653 PyObject *swig_obj[1] ;
14654
14655 if (!args) SWIG_fail;
14656 swig_obj[0] = args;
14657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14658 if (!SWIG_IsOK(res1)) {
14659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14660 }
14661 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14662 {
14663 PyThreadState* __tstate = wxPyBeginAllowThreads();
14664 result = (wxInputStream *)(arg1)->GetInputStream();
14665 wxPyEndAllowThreads(__tstate);
14666 if (PyErr_Occurred()) SWIG_fail;
14667 }
14668 {
14669 wxPyInputStream * _ptr = NULL;
14670
14671 if (result) {
14672 _ptr = new wxPyInputStream(result);
14673 }
14674 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14675 }
14676 return resultobj;
14677 fail:
14678 return NULL;
14679 }
14680
14681
14682 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14683 PyObject *resultobj = 0;
14684 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14685 wxInputStream *result = 0 ;
14686 void *argp1 = 0 ;
14687 int res1 = 0 ;
14688 PyObject *swig_obj[1] ;
14689
14690 if (!args) SWIG_fail;
14691 swig_obj[0] = args;
14692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14693 if (!SWIG_IsOK(res1)) {
14694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14695 }
14696 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14697 {
14698 PyThreadState* __tstate = wxPyBeginAllowThreads();
14699 result = (wxInputStream *)(arg1)->GetErrorStream();
14700 wxPyEndAllowThreads(__tstate);
14701 if (PyErr_Occurred()) SWIG_fail;
14702 }
14703 {
14704 wxPyInputStream * _ptr = NULL;
14705
14706 if (result) {
14707 _ptr = new wxPyInputStream(result);
14708 }
14709 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14710 }
14711 return resultobj;
14712 fail:
14713 return NULL;
14714 }
14715
14716
14717 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14718 PyObject *resultobj = 0;
14719 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14720 wxOutputStream *result = 0 ;
14721 void *argp1 = 0 ;
14722 int res1 = 0 ;
14723 PyObject *swig_obj[1] ;
14724
14725 if (!args) SWIG_fail;
14726 swig_obj[0] = args;
14727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14728 if (!SWIG_IsOK(res1)) {
14729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14730 }
14731 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14732 {
14733 PyThreadState* __tstate = wxPyBeginAllowThreads();
14734 result = (wxOutputStream *)(arg1)->GetOutputStream();
14735 wxPyEndAllowThreads(__tstate);
14736 if (PyErr_Occurred()) SWIG_fail;
14737 }
14738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14739 return resultobj;
14740 fail:
14741 return NULL;
14742 }
14743
14744
14745 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14746 PyObject *resultobj = 0;
14747 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14748 void *argp1 = 0 ;
14749 int res1 = 0 ;
14750 PyObject *swig_obj[1] ;
14751
14752 if (!args) SWIG_fail;
14753 swig_obj[0] = args;
14754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14755 if (!SWIG_IsOK(res1)) {
14756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14757 }
14758 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14759 {
14760 PyThreadState* __tstate = wxPyBeginAllowThreads();
14761 (arg1)->CloseOutput();
14762 wxPyEndAllowThreads(__tstate);
14763 if (PyErr_Occurred()) SWIG_fail;
14764 }
14765 resultobj = SWIG_Py_Void();
14766 return resultobj;
14767 fail:
14768 return NULL;
14769 }
14770
14771
14772 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14773 PyObject *resultobj = 0;
14774 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14775 bool result;
14776 void *argp1 = 0 ;
14777 int res1 = 0 ;
14778 PyObject *swig_obj[1] ;
14779
14780 if (!args) SWIG_fail;
14781 swig_obj[0] = args;
14782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14783 if (!SWIG_IsOK(res1)) {
14784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14785 }
14786 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14787 {
14788 PyThreadState* __tstate = wxPyBeginAllowThreads();
14789 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14790 wxPyEndAllowThreads(__tstate);
14791 if (PyErr_Occurred()) SWIG_fail;
14792 }
14793 {
14794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14795 }
14796 return resultobj;
14797 fail:
14798 return NULL;
14799 }
14800
14801
14802 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14803 PyObject *resultobj = 0;
14804 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14805 bool result;
14806 void *argp1 = 0 ;
14807 int res1 = 0 ;
14808 PyObject *swig_obj[1] ;
14809
14810 if (!args) SWIG_fail;
14811 swig_obj[0] = args;
14812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14813 if (!SWIG_IsOK(res1)) {
14814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14815 }
14816 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14817 {
14818 PyThreadState* __tstate = wxPyBeginAllowThreads();
14819 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14820 wxPyEndAllowThreads(__tstate);
14821 if (PyErr_Occurred()) SWIG_fail;
14822 }
14823 {
14824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14825 }
14826 return resultobj;
14827 fail:
14828 return NULL;
14829 }
14830
14831
14832 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14833 PyObject *resultobj = 0;
14834 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14835 bool result;
14836 void *argp1 = 0 ;
14837 int res1 = 0 ;
14838 PyObject *swig_obj[1] ;
14839
14840 if (!args) SWIG_fail;
14841 swig_obj[0] = args;
14842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14843 if (!SWIG_IsOK(res1)) {
14844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14845 }
14846 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14847 {
14848 PyThreadState* __tstate = wxPyBeginAllowThreads();
14849 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14850 wxPyEndAllowThreads(__tstate);
14851 if (PyErr_Occurred()) SWIG_fail;
14852 }
14853 {
14854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14855 }
14856 return resultobj;
14857 fail:
14858 return NULL;
14859 }
14860
14861
14862 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14863 PyObject *obj;
14864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14865 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14866 return SWIG_Py_Void();
14867 }
14868
14869 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14870 return SWIG_Python_InitShadowInstance(args);
14871 }
14872
14873 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14874 PyObject *resultobj = 0;
14875 int arg1 = (int) 0 ;
14876 int arg2 = (int) 0 ;
14877 int arg3 = (int) 0 ;
14878 wxProcessEvent *result = 0 ;
14879 int val1 ;
14880 int ecode1 = 0 ;
14881 int val2 ;
14882 int ecode2 = 0 ;
14883 int val3 ;
14884 int ecode3 = 0 ;
14885 PyObject * obj0 = 0 ;
14886 PyObject * obj1 = 0 ;
14887 PyObject * obj2 = 0 ;
14888 char * kwnames[] = {
14889 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14890 };
14891
14892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14893 if (obj0) {
14894 ecode1 = SWIG_AsVal_int(obj0, &val1);
14895 if (!SWIG_IsOK(ecode1)) {
14896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14897 }
14898 arg1 = static_cast< int >(val1);
14899 }
14900 if (obj1) {
14901 ecode2 = SWIG_AsVal_int(obj1, &val2);
14902 if (!SWIG_IsOK(ecode2)) {
14903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14904 }
14905 arg2 = static_cast< int >(val2);
14906 }
14907 if (obj2) {
14908 ecode3 = SWIG_AsVal_int(obj2, &val3);
14909 if (!SWIG_IsOK(ecode3)) {
14910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14911 }
14912 arg3 = static_cast< int >(val3);
14913 }
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14917 wxPyEndAllowThreads(__tstate);
14918 if (PyErr_Occurred()) SWIG_fail;
14919 }
14920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14921 return resultobj;
14922 fail:
14923 return NULL;
14924 }
14925
14926
14927 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14928 PyObject *resultobj = 0;
14929 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14930 int result;
14931 void *argp1 = 0 ;
14932 int res1 = 0 ;
14933 PyObject *swig_obj[1] ;
14934
14935 if (!args) SWIG_fail;
14936 swig_obj[0] = args;
14937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14938 if (!SWIG_IsOK(res1)) {
14939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14940 }
14941 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 result = (int)(arg1)->GetPid();
14945 wxPyEndAllowThreads(__tstate);
14946 if (PyErr_Occurred()) SWIG_fail;
14947 }
14948 resultobj = SWIG_From_int(static_cast< int >(result));
14949 return resultobj;
14950 fail:
14951 return NULL;
14952 }
14953
14954
14955 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14956 PyObject *resultobj = 0;
14957 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14958 int result;
14959 void *argp1 = 0 ;
14960 int res1 = 0 ;
14961 PyObject *swig_obj[1] ;
14962
14963 if (!args) SWIG_fail;
14964 swig_obj[0] = args;
14965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14966 if (!SWIG_IsOK(res1)) {
14967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14968 }
14969 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14970 {
14971 PyThreadState* __tstate = wxPyBeginAllowThreads();
14972 result = (int)(arg1)->GetExitCode();
14973 wxPyEndAllowThreads(__tstate);
14974 if (PyErr_Occurred()) SWIG_fail;
14975 }
14976 resultobj = SWIG_From_int(static_cast< int >(result));
14977 return resultobj;
14978 fail:
14979 return NULL;
14980 }
14981
14982
14983 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14984 PyObject *resultobj = 0;
14985 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14986 int arg2 ;
14987 void *argp1 = 0 ;
14988 int res1 = 0 ;
14989 int val2 ;
14990 int ecode2 = 0 ;
14991 PyObject *swig_obj[2] ;
14992
14993 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14995 if (!SWIG_IsOK(res1)) {
14996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14997 }
14998 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14999 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15000 if (!SWIG_IsOK(ecode2)) {
15001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
15002 }
15003 arg2 = static_cast< int >(val2);
15004 if (arg1) (arg1)->m_pid = arg2;
15005
15006 resultobj = SWIG_Py_Void();
15007 return resultobj;
15008 fail:
15009 return NULL;
15010 }
15011
15012
15013 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15014 PyObject *resultobj = 0;
15015 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15016 int result;
15017 void *argp1 = 0 ;
15018 int res1 = 0 ;
15019 PyObject *swig_obj[1] ;
15020
15021 if (!args) SWIG_fail;
15022 swig_obj[0] = args;
15023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15024 if (!SWIG_IsOK(res1)) {
15025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15026 }
15027 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15028 result = (int) ((arg1)->m_pid);
15029 resultobj = SWIG_From_int(static_cast< int >(result));
15030 return resultobj;
15031 fail:
15032 return NULL;
15033 }
15034
15035
15036 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15037 PyObject *resultobj = 0;
15038 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15039 int arg2 ;
15040 void *argp1 = 0 ;
15041 int res1 = 0 ;
15042 int val2 ;
15043 int ecode2 = 0 ;
15044 PyObject *swig_obj[2] ;
15045
15046 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15048 if (!SWIG_IsOK(res1)) {
15049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15050 }
15051 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15052 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15053 if (!SWIG_IsOK(ecode2)) {
15054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15055 }
15056 arg2 = static_cast< int >(val2);
15057 if (arg1) (arg1)->m_exitcode = arg2;
15058
15059 resultobj = SWIG_Py_Void();
15060 return resultobj;
15061 fail:
15062 return NULL;
15063 }
15064
15065
15066 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15067 PyObject *resultobj = 0;
15068 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15069 int result;
15070 void *argp1 = 0 ;
15071 int res1 = 0 ;
15072 PyObject *swig_obj[1] ;
15073
15074 if (!args) SWIG_fail;
15075 swig_obj[0] = args;
15076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15077 if (!SWIG_IsOK(res1)) {
15078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15079 }
15080 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15081 result = (int) ((arg1)->m_exitcode);
15082 resultobj = SWIG_From_int(static_cast< int >(result));
15083 return resultobj;
15084 fail:
15085 return NULL;
15086 }
15087
15088
15089 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15090 PyObject *obj;
15091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15092 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15093 return SWIG_Py_Void();
15094 }
15095
15096 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15097 return SWIG_Python_InitShadowInstance(args);
15098 }
15099
15100 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15101 PyObject *resultobj = 0;
15102 wxString *arg1 = 0 ;
15103 int arg2 = (int) wxEXEC_ASYNC ;
15104 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15105 long result;
15106 bool temp1 = false ;
15107 int val2 ;
15108 int ecode2 = 0 ;
15109 void *argp3 = 0 ;
15110 int res3 = 0 ;
15111 PyObject * obj0 = 0 ;
15112 PyObject * obj1 = 0 ;
15113 PyObject * obj2 = 0 ;
15114 char * kwnames[] = {
15115 (char *) "command",(char *) "flags",(char *) "process", NULL
15116 };
15117
15118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15119 {
15120 arg1 = wxString_in_helper(obj0);
15121 if (arg1 == NULL) SWIG_fail;
15122 temp1 = true;
15123 }
15124 if (obj1) {
15125 ecode2 = SWIG_AsVal_int(obj1, &val2);
15126 if (!SWIG_IsOK(ecode2)) {
15127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15128 }
15129 arg2 = static_cast< int >(val2);
15130 }
15131 if (obj2) {
15132 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15133 if (!SWIG_IsOK(res3)) {
15134 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15135 }
15136 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15137 }
15138 {
15139 if (!wxPyCheckForApp()) SWIG_fail;
15140 PyThreadState* __tstate = wxPyBeginAllowThreads();
15141 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15142 wxPyEndAllowThreads(__tstate);
15143 if (PyErr_Occurred()) SWIG_fail;
15144 }
15145 resultobj = SWIG_From_long(static_cast< long >(result));
15146 {
15147 if (temp1)
15148 delete arg1;
15149 }
15150 return resultobj;
15151 fail:
15152 {
15153 if (temp1)
15154 delete arg1;
15155 }
15156 return NULL;
15157 }
15158
15159
15160 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15161 PyObject *resultobj = 0;
15162 long arg1 ;
15163 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15164 wxKillError *arg3 = (wxKillError *) 0 ;
15165 int arg4 = (int) wxKILL_NOCHILDREN ;
15166 int result;
15167 long val1 ;
15168 int ecode1 = 0 ;
15169 int val2 ;
15170 int ecode2 = 0 ;
15171 wxKillError temp3 ;
15172 int val4 ;
15173 int ecode4 = 0 ;
15174 PyObject * obj0 = 0 ;
15175 PyObject * obj1 = 0 ;
15176 PyObject * obj2 = 0 ;
15177 char * kwnames[] = {
15178 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15179 };
15180
15181 {
15182 arg3 = &temp3;
15183 }
15184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15185 ecode1 = SWIG_AsVal_long(obj0, &val1);
15186 if (!SWIG_IsOK(ecode1)) {
15187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15188 }
15189 arg1 = static_cast< long >(val1);
15190 if (obj1) {
15191 ecode2 = SWIG_AsVal_int(obj1, &val2);
15192 if (!SWIG_IsOK(ecode2)) {
15193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15194 }
15195 arg2 = static_cast< wxSignal >(val2);
15196 }
15197 if (obj2) {
15198 ecode4 = SWIG_AsVal_int(obj2, &val4);
15199 if (!SWIG_IsOK(ecode4)) {
15200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15201 }
15202 arg4 = static_cast< int >(val4);
15203 }
15204 {
15205 PyThreadState* __tstate = wxPyBeginAllowThreads();
15206 result = (int)wxKill(arg1,arg2,arg3,arg4);
15207 wxPyEndAllowThreads(__tstate);
15208 if (PyErr_Occurred()) SWIG_fail;
15209 }
15210 resultobj = SWIG_From_int(static_cast< int >(result));
15211 {
15212 PyObject* o;
15213 o = PyInt_FromLong((long) (*arg3));
15214
15215
15216
15217 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15218
15219 }
15220 return resultobj;
15221 fail:
15222 return NULL;
15223 }
15224
15225
15226 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15227 PyObject *resultobj = 0;
15228 int arg1 = (int) wxJOYSTICK1 ;
15229 wxJoystick *result = 0 ;
15230 int val1 ;
15231 int ecode1 = 0 ;
15232 PyObject * obj0 = 0 ;
15233 char * kwnames[] = {
15234 (char *) "joystick", NULL
15235 };
15236
15237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15238 if (obj0) {
15239 ecode1 = SWIG_AsVal_int(obj0, &val1);
15240 if (!SWIG_IsOK(ecode1)) {
15241 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15242 }
15243 arg1 = static_cast< int >(val1);
15244 }
15245 {
15246 if (!wxPyCheckForApp()) SWIG_fail;
15247 PyThreadState* __tstate = wxPyBeginAllowThreads();
15248 result = (wxJoystick *)new wxJoystick(arg1);
15249 wxPyEndAllowThreads(__tstate);
15250 if (PyErr_Occurred()) SWIG_fail;
15251 }
15252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15253 return resultobj;
15254 fail:
15255 return NULL;
15256 }
15257
15258
15259 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15260 PyObject *resultobj = 0;
15261 wxJoystick *arg1 = (wxJoystick *) 0 ;
15262 void *argp1 = 0 ;
15263 int res1 = 0 ;
15264 PyObject *swig_obj[1] ;
15265
15266 if (!args) SWIG_fail;
15267 swig_obj[0] = args;
15268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15269 if (!SWIG_IsOK(res1)) {
15270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15271 }
15272 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15273 {
15274 PyThreadState* __tstate = wxPyBeginAllowThreads();
15275 delete arg1;
15276
15277 wxPyEndAllowThreads(__tstate);
15278 if (PyErr_Occurred()) SWIG_fail;
15279 }
15280 resultobj = SWIG_Py_Void();
15281 return resultobj;
15282 fail:
15283 return NULL;
15284 }
15285
15286
15287 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15288 PyObject *resultobj = 0;
15289 wxJoystick *arg1 = (wxJoystick *) 0 ;
15290 wxPoint result;
15291 void *argp1 = 0 ;
15292 int res1 = 0 ;
15293 PyObject *swig_obj[1] ;
15294
15295 if (!args) SWIG_fail;
15296 swig_obj[0] = args;
15297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15298 if (!SWIG_IsOK(res1)) {
15299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15300 }
15301 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15302 {
15303 PyThreadState* __tstate = wxPyBeginAllowThreads();
15304 result = (arg1)->GetPosition();
15305 wxPyEndAllowThreads(__tstate);
15306 if (PyErr_Occurred()) SWIG_fail;
15307 }
15308 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15309 return resultobj;
15310 fail:
15311 return NULL;
15312 }
15313
15314
15315 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15316 PyObject *resultobj = 0;
15317 wxJoystick *arg1 = (wxJoystick *) 0 ;
15318 int result;
15319 void *argp1 = 0 ;
15320 int res1 = 0 ;
15321 PyObject *swig_obj[1] ;
15322
15323 if (!args) SWIG_fail;
15324 swig_obj[0] = args;
15325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15326 if (!SWIG_IsOK(res1)) {
15327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15328 }
15329 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15330 {
15331 PyThreadState* __tstate = wxPyBeginAllowThreads();
15332 result = (int)(arg1)->GetZPosition();
15333 wxPyEndAllowThreads(__tstate);
15334 if (PyErr_Occurred()) SWIG_fail;
15335 }
15336 resultobj = SWIG_From_int(static_cast< int >(result));
15337 return resultobj;
15338 fail:
15339 return NULL;
15340 }
15341
15342
15343 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15344 PyObject *resultobj = 0;
15345 wxJoystick *arg1 = (wxJoystick *) 0 ;
15346 int result;
15347 void *argp1 = 0 ;
15348 int res1 = 0 ;
15349 PyObject *swig_obj[1] ;
15350
15351 if (!args) SWIG_fail;
15352 swig_obj[0] = args;
15353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15354 if (!SWIG_IsOK(res1)) {
15355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15356 }
15357 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15358 {
15359 PyThreadState* __tstate = wxPyBeginAllowThreads();
15360 result = (int)(arg1)->GetButtonState();
15361 wxPyEndAllowThreads(__tstate);
15362 if (PyErr_Occurred()) SWIG_fail;
15363 }
15364 resultobj = SWIG_From_int(static_cast< int >(result));
15365 return resultobj;
15366 fail:
15367 return NULL;
15368 }
15369
15370
15371 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15372 PyObject *resultobj = 0;
15373 wxJoystick *arg1 = (wxJoystick *) 0 ;
15374 int result;
15375 void *argp1 = 0 ;
15376 int res1 = 0 ;
15377 PyObject *swig_obj[1] ;
15378
15379 if (!args) SWIG_fail;
15380 swig_obj[0] = args;
15381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15382 if (!SWIG_IsOK(res1)) {
15383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15384 }
15385 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15386 {
15387 PyThreadState* __tstate = wxPyBeginAllowThreads();
15388 result = (int)(arg1)->GetPOVPosition();
15389 wxPyEndAllowThreads(__tstate);
15390 if (PyErr_Occurred()) SWIG_fail;
15391 }
15392 resultobj = SWIG_From_int(static_cast< int >(result));
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15400 PyObject *resultobj = 0;
15401 wxJoystick *arg1 = (wxJoystick *) 0 ;
15402 int result;
15403 void *argp1 = 0 ;
15404 int res1 = 0 ;
15405 PyObject *swig_obj[1] ;
15406
15407 if (!args) SWIG_fail;
15408 swig_obj[0] = args;
15409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15412 }
15413 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (int)(arg1)->GetPOVCTSPosition();
15417 wxPyEndAllowThreads(__tstate);
15418 if (PyErr_Occurred()) SWIG_fail;
15419 }
15420 resultobj = SWIG_From_int(static_cast< int >(result));
15421 return resultobj;
15422 fail:
15423 return NULL;
15424 }
15425
15426
15427 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15428 PyObject *resultobj = 0;
15429 wxJoystick *arg1 = (wxJoystick *) 0 ;
15430 int result;
15431 void *argp1 = 0 ;
15432 int res1 = 0 ;
15433 PyObject *swig_obj[1] ;
15434
15435 if (!args) SWIG_fail;
15436 swig_obj[0] = args;
15437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15438 if (!SWIG_IsOK(res1)) {
15439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15440 }
15441 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15442 {
15443 PyThreadState* __tstate = wxPyBeginAllowThreads();
15444 result = (int)(arg1)->GetRudderPosition();
15445 wxPyEndAllowThreads(__tstate);
15446 if (PyErr_Occurred()) SWIG_fail;
15447 }
15448 resultobj = SWIG_From_int(static_cast< int >(result));
15449 return resultobj;
15450 fail:
15451 return NULL;
15452 }
15453
15454
15455 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15456 PyObject *resultobj = 0;
15457 wxJoystick *arg1 = (wxJoystick *) 0 ;
15458 int result;
15459 void *argp1 = 0 ;
15460 int res1 = 0 ;
15461 PyObject *swig_obj[1] ;
15462
15463 if (!args) SWIG_fail;
15464 swig_obj[0] = args;
15465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15466 if (!SWIG_IsOK(res1)) {
15467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15468 }
15469 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15470 {
15471 PyThreadState* __tstate = wxPyBeginAllowThreads();
15472 result = (int)(arg1)->GetUPosition();
15473 wxPyEndAllowThreads(__tstate);
15474 if (PyErr_Occurred()) SWIG_fail;
15475 }
15476 resultobj = SWIG_From_int(static_cast< int >(result));
15477 return resultobj;
15478 fail:
15479 return NULL;
15480 }
15481
15482
15483 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15484 PyObject *resultobj = 0;
15485 wxJoystick *arg1 = (wxJoystick *) 0 ;
15486 int result;
15487 void *argp1 = 0 ;
15488 int res1 = 0 ;
15489 PyObject *swig_obj[1] ;
15490
15491 if (!args) SWIG_fail;
15492 swig_obj[0] = args;
15493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15494 if (!SWIG_IsOK(res1)) {
15495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15496 }
15497 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15498 {
15499 PyThreadState* __tstate = wxPyBeginAllowThreads();
15500 result = (int)(arg1)->GetVPosition();
15501 wxPyEndAllowThreads(__tstate);
15502 if (PyErr_Occurred()) SWIG_fail;
15503 }
15504 resultobj = SWIG_From_int(static_cast< int >(result));
15505 return resultobj;
15506 fail:
15507 return NULL;
15508 }
15509
15510
15511 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15512 PyObject *resultobj = 0;
15513 wxJoystick *arg1 = (wxJoystick *) 0 ;
15514 int result;
15515 void *argp1 = 0 ;
15516 int res1 = 0 ;
15517 PyObject *swig_obj[1] ;
15518
15519 if (!args) SWIG_fail;
15520 swig_obj[0] = args;
15521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15522 if (!SWIG_IsOK(res1)) {
15523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15524 }
15525 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15526 {
15527 PyThreadState* __tstate = wxPyBeginAllowThreads();
15528 result = (int)(arg1)->GetMovementThreshold();
15529 wxPyEndAllowThreads(__tstate);
15530 if (PyErr_Occurred()) SWIG_fail;
15531 }
15532 resultobj = SWIG_From_int(static_cast< int >(result));
15533 return resultobj;
15534 fail:
15535 return NULL;
15536 }
15537
15538
15539 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15540 PyObject *resultobj = 0;
15541 wxJoystick *arg1 = (wxJoystick *) 0 ;
15542 int arg2 ;
15543 void *argp1 = 0 ;
15544 int res1 = 0 ;
15545 int val2 ;
15546 int ecode2 = 0 ;
15547 PyObject * obj0 = 0 ;
15548 PyObject * obj1 = 0 ;
15549 char * kwnames[] = {
15550 (char *) "self",(char *) "threshold", NULL
15551 };
15552
15553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15555 if (!SWIG_IsOK(res1)) {
15556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15557 }
15558 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15559 ecode2 = SWIG_AsVal_int(obj1, &val2);
15560 if (!SWIG_IsOK(ecode2)) {
15561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15562 }
15563 arg2 = static_cast< int >(val2);
15564 {
15565 PyThreadState* __tstate = wxPyBeginAllowThreads();
15566 (arg1)->SetMovementThreshold(arg2);
15567 wxPyEndAllowThreads(__tstate);
15568 if (PyErr_Occurred()) SWIG_fail;
15569 }
15570 resultobj = SWIG_Py_Void();
15571 return resultobj;
15572 fail:
15573 return NULL;
15574 }
15575
15576
15577 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15578 PyObject *resultobj = 0;
15579 wxJoystick *arg1 = (wxJoystick *) 0 ;
15580 bool result;
15581 void *argp1 = 0 ;
15582 int res1 = 0 ;
15583 PyObject *swig_obj[1] ;
15584
15585 if (!args) SWIG_fail;
15586 swig_obj[0] = args;
15587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15588 if (!SWIG_IsOK(res1)) {
15589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15590 }
15591 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15592 {
15593 PyThreadState* __tstate = wxPyBeginAllowThreads();
15594 result = (bool)(arg1)->IsOk();
15595 wxPyEndAllowThreads(__tstate);
15596 if (PyErr_Occurred()) SWIG_fail;
15597 }
15598 {
15599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15600 }
15601 return resultobj;
15602 fail:
15603 return NULL;
15604 }
15605
15606
15607 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15608 PyObject *resultobj = 0;
15609 wxJoystick *arg1 = (wxJoystick *) 0 ;
15610 int result;
15611 void *argp1 = 0 ;
15612 int res1 = 0 ;
15613 PyObject *swig_obj[1] ;
15614
15615 if (!args) SWIG_fail;
15616 swig_obj[0] = args;
15617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15618 if (!SWIG_IsOK(res1)) {
15619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15620 }
15621 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15622 {
15623 PyThreadState* __tstate = wxPyBeginAllowThreads();
15624 result = (int)(arg1)->GetNumberJoysticks();
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 resultobj = SWIG_From_int(static_cast< int >(result));
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15636 PyObject *resultobj = 0;
15637 wxJoystick *arg1 = (wxJoystick *) 0 ;
15638 int result;
15639 void *argp1 = 0 ;
15640 int res1 = 0 ;
15641 PyObject *swig_obj[1] ;
15642
15643 if (!args) SWIG_fail;
15644 swig_obj[0] = args;
15645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15646 if (!SWIG_IsOK(res1)) {
15647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15648 }
15649 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15650 {
15651 PyThreadState* __tstate = wxPyBeginAllowThreads();
15652 result = (int)(arg1)->GetManufacturerId();
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 resultobj = SWIG_From_int(static_cast< int >(result));
15657 return resultobj;
15658 fail:
15659 return NULL;
15660 }
15661
15662
15663 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15664 PyObject *resultobj = 0;
15665 wxJoystick *arg1 = (wxJoystick *) 0 ;
15666 int result;
15667 void *argp1 = 0 ;
15668 int res1 = 0 ;
15669 PyObject *swig_obj[1] ;
15670
15671 if (!args) SWIG_fail;
15672 swig_obj[0] = args;
15673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15674 if (!SWIG_IsOK(res1)) {
15675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15676 }
15677 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15678 {
15679 PyThreadState* __tstate = wxPyBeginAllowThreads();
15680 result = (int)(arg1)->GetProductId();
15681 wxPyEndAllowThreads(__tstate);
15682 if (PyErr_Occurred()) SWIG_fail;
15683 }
15684 resultobj = SWIG_From_int(static_cast< int >(result));
15685 return resultobj;
15686 fail:
15687 return NULL;
15688 }
15689
15690
15691 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15692 PyObject *resultobj = 0;
15693 wxJoystick *arg1 = (wxJoystick *) 0 ;
15694 wxString result;
15695 void *argp1 = 0 ;
15696 int res1 = 0 ;
15697 PyObject *swig_obj[1] ;
15698
15699 if (!args) SWIG_fail;
15700 swig_obj[0] = args;
15701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15702 if (!SWIG_IsOK(res1)) {
15703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15704 }
15705 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15706 {
15707 PyThreadState* __tstate = wxPyBeginAllowThreads();
15708 result = (arg1)->GetProductName();
15709 wxPyEndAllowThreads(__tstate);
15710 if (PyErr_Occurred()) SWIG_fail;
15711 }
15712 {
15713 #if wxUSE_UNICODE
15714 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15715 #else
15716 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15717 #endif
15718 }
15719 return resultobj;
15720 fail:
15721 return NULL;
15722 }
15723
15724
15725 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15726 PyObject *resultobj = 0;
15727 wxJoystick *arg1 = (wxJoystick *) 0 ;
15728 int result;
15729 void *argp1 = 0 ;
15730 int res1 = 0 ;
15731 PyObject *swig_obj[1] ;
15732
15733 if (!args) SWIG_fail;
15734 swig_obj[0] = args;
15735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15736 if (!SWIG_IsOK(res1)) {
15737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15738 }
15739 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 result = (int)(arg1)->GetXMin();
15743 wxPyEndAllowThreads(__tstate);
15744 if (PyErr_Occurred()) SWIG_fail;
15745 }
15746 resultobj = SWIG_From_int(static_cast< int >(result));
15747 return resultobj;
15748 fail:
15749 return NULL;
15750 }
15751
15752
15753 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15754 PyObject *resultobj = 0;
15755 wxJoystick *arg1 = (wxJoystick *) 0 ;
15756 int result;
15757 void *argp1 = 0 ;
15758 int res1 = 0 ;
15759 PyObject *swig_obj[1] ;
15760
15761 if (!args) SWIG_fail;
15762 swig_obj[0] = args;
15763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15764 if (!SWIG_IsOK(res1)) {
15765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15766 }
15767 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15768 {
15769 PyThreadState* __tstate = wxPyBeginAllowThreads();
15770 result = (int)(arg1)->GetYMin();
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 resultobj = SWIG_From_int(static_cast< int >(result));
15775 return resultobj;
15776 fail:
15777 return NULL;
15778 }
15779
15780
15781 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15782 PyObject *resultobj = 0;
15783 wxJoystick *arg1 = (wxJoystick *) 0 ;
15784 int result;
15785 void *argp1 = 0 ;
15786 int res1 = 0 ;
15787 PyObject *swig_obj[1] ;
15788
15789 if (!args) SWIG_fail;
15790 swig_obj[0] = args;
15791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15792 if (!SWIG_IsOK(res1)) {
15793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15794 }
15795 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15796 {
15797 PyThreadState* __tstate = wxPyBeginAllowThreads();
15798 result = (int)(arg1)->GetZMin();
15799 wxPyEndAllowThreads(__tstate);
15800 if (PyErr_Occurred()) SWIG_fail;
15801 }
15802 resultobj = SWIG_From_int(static_cast< int >(result));
15803 return resultobj;
15804 fail:
15805 return NULL;
15806 }
15807
15808
15809 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15810 PyObject *resultobj = 0;
15811 wxJoystick *arg1 = (wxJoystick *) 0 ;
15812 int result;
15813 void *argp1 = 0 ;
15814 int res1 = 0 ;
15815 PyObject *swig_obj[1] ;
15816
15817 if (!args) SWIG_fail;
15818 swig_obj[0] = args;
15819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15820 if (!SWIG_IsOK(res1)) {
15821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15822 }
15823 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15824 {
15825 PyThreadState* __tstate = wxPyBeginAllowThreads();
15826 result = (int)(arg1)->GetXMax();
15827 wxPyEndAllowThreads(__tstate);
15828 if (PyErr_Occurred()) SWIG_fail;
15829 }
15830 resultobj = SWIG_From_int(static_cast< int >(result));
15831 return resultobj;
15832 fail:
15833 return NULL;
15834 }
15835
15836
15837 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15838 PyObject *resultobj = 0;
15839 wxJoystick *arg1 = (wxJoystick *) 0 ;
15840 int result;
15841 void *argp1 = 0 ;
15842 int res1 = 0 ;
15843 PyObject *swig_obj[1] ;
15844
15845 if (!args) SWIG_fail;
15846 swig_obj[0] = args;
15847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15848 if (!SWIG_IsOK(res1)) {
15849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15850 }
15851 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15852 {
15853 PyThreadState* __tstate = wxPyBeginAllowThreads();
15854 result = (int)(arg1)->GetYMax();
15855 wxPyEndAllowThreads(__tstate);
15856 if (PyErr_Occurred()) SWIG_fail;
15857 }
15858 resultobj = SWIG_From_int(static_cast< int >(result));
15859 return resultobj;
15860 fail:
15861 return NULL;
15862 }
15863
15864
15865 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15866 PyObject *resultobj = 0;
15867 wxJoystick *arg1 = (wxJoystick *) 0 ;
15868 int result;
15869 void *argp1 = 0 ;
15870 int res1 = 0 ;
15871 PyObject *swig_obj[1] ;
15872
15873 if (!args) SWIG_fail;
15874 swig_obj[0] = args;
15875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15876 if (!SWIG_IsOK(res1)) {
15877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15878 }
15879 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15880 {
15881 PyThreadState* __tstate = wxPyBeginAllowThreads();
15882 result = (int)(arg1)->GetZMax();
15883 wxPyEndAllowThreads(__tstate);
15884 if (PyErr_Occurred()) SWIG_fail;
15885 }
15886 resultobj = SWIG_From_int(static_cast< int >(result));
15887 return resultobj;
15888 fail:
15889 return NULL;
15890 }
15891
15892
15893 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15894 PyObject *resultobj = 0;
15895 wxJoystick *arg1 = (wxJoystick *) 0 ;
15896 int result;
15897 void *argp1 = 0 ;
15898 int res1 = 0 ;
15899 PyObject *swig_obj[1] ;
15900
15901 if (!args) SWIG_fail;
15902 swig_obj[0] = args;
15903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15904 if (!SWIG_IsOK(res1)) {
15905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15906 }
15907 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15908 {
15909 PyThreadState* __tstate = wxPyBeginAllowThreads();
15910 result = (int)(arg1)->GetNumberButtons();
15911 wxPyEndAllowThreads(__tstate);
15912 if (PyErr_Occurred()) SWIG_fail;
15913 }
15914 resultobj = SWIG_From_int(static_cast< int >(result));
15915 return resultobj;
15916 fail:
15917 return NULL;
15918 }
15919
15920
15921 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15922 PyObject *resultobj = 0;
15923 wxJoystick *arg1 = (wxJoystick *) 0 ;
15924 int result;
15925 void *argp1 = 0 ;
15926 int res1 = 0 ;
15927 PyObject *swig_obj[1] ;
15928
15929 if (!args) SWIG_fail;
15930 swig_obj[0] = args;
15931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15932 if (!SWIG_IsOK(res1)) {
15933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15934 }
15935 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15936 {
15937 PyThreadState* __tstate = wxPyBeginAllowThreads();
15938 result = (int)(arg1)->GetNumberAxes();
15939 wxPyEndAllowThreads(__tstate);
15940 if (PyErr_Occurred()) SWIG_fail;
15941 }
15942 resultobj = SWIG_From_int(static_cast< int >(result));
15943 return resultobj;
15944 fail:
15945 return NULL;
15946 }
15947
15948
15949 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15950 PyObject *resultobj = 0;
15951 wxJoystick *arg1 = (wxJoystick *) 0 ;
15952 int result;
15953 void *argp1 = 0 ;
15954 int res1 = 0 ;
15955 PyObject *swig_obj[1] ;
15956
15957 if (!args) SWIG_fail;
15958 swig_obj[0] = args;
15959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15960 if (!SWIG_IsOK(res1)) {
15961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15962 }
15963 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15964 {
15965 PyThreadState* __tstate = wxPyBeginAllowThreads();
15966 result = (int)(arg1)->GetMaxButtons();
15967 wxPyEndAllowThreads(__tstate);
15968 if (PyErr_Occurred()) SWIG_fail;
15969 }
15970 resultobj = SWIG_From_int(static_cast< int >(result));
15971 return resultobj;
15972 fail:
15973 return NULL;
15974 }
15975
15976
15977 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15978 PyObject *resultobj = 0;
15979 wxJoystick *arg1 = (wxJoystick *) 0 ;
15980 int result;
15981 void *argp1 = 0 ;
15982 int res1 = 0 ;
15983 PyObject *swig_obj[1] ;
15984
15985 if (!args) SWIG_fail;
15986 swig_obj[0] = args;
15987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15988 if (!SWIG_IsOK(res1)) {
15989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15990 }
15991 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15992 {
15993 PyThreadState* __tstate = wxPyBeginAllowThreads();
15994 result = (int)(arg1)->GetMaxAxes();
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 resultobj = SWIG_From_int(static_cast< int >(result));
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16006 PyObject *resultobj = 0;
16007 wxJoystick *arg1 = (wxJoystick *) 0 ;
16008 int result;
16009 void *argp1 = 0 ;
16010 int res1 = 0 ;
16011 PyObject *swig_obj[1] ;
16012
16013 if (!args) SWIG_fail;
16014 swig_obj[0] = args;
16015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16016 if (!SWIG_IsOK(res1)) {
16017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16018 }
16019 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16020 {
16021 PyThreadState* __tstate = wxPyBeginAllowThreads();
16022 result = (int)(arg1)->GetPollingMin();
16023 wxPyEndAllowThreads(__tstate);
16024 if (PyErr_Occurred()) SWIG_fail;
16025 }
16026 resultobj = SWIG_From_int(static_cast< int >(result));
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16034 PyObject *resultobj = 0;
16035 wxJoystick *arg1 = (wxJoystick *) 0 ;
16036 int result;
16037 void *argp1 = 0 ;
16038 int res1 = 0 ;
16039 PyObject *swig_obj[1] ;
16040
16041 if (!args) SWIG_fail;
16042 swig_obj[0] = args;
16043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16044 if (!SWIG_IsOK(res1)) {
16045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16046 }
16047 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16048 {
16049 PyThreadState* __tstate = wxPyBeginAllowThreads();
16050 result = (int)(arg1)->GetPollingMax();
16051 wxPyEndAllowThreads(__tstate);
16052 if (PyErr_Occurred()) SWIG_fail;
16053 }
16054 resultobj = SWIG_From_int(static_cast< int >(result));
16055 return resultobj;
16056 fail:
16057 return NULL;
16058 }
16059
16060
16061 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16062 PyObject *resultobj = 0;
16063 wxJoystick *arg1 = (wxJoystick *) 0 ;
16064 int result;
16065 void *argp1 = 0 ;
16066 int res1 = 0 ;
16067 PyObject *swig_obj[1] ;
16068
16069 if (!args) SWIG_fail;
16070 swig_obj[0] = args;
16071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16072 if (!SWIG_IsOK(res1)) {
16073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16074 }
16075 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16076 {
16077 PyThreadState* __tstate = wxPyBeginAllowThreads();
16078 result = (int)(arg1)->GetRudderMin();
16079 wxPyEndAllowThreads(__tstate);
16080 if (PyErr_Occurred()) SWIG_fail;
16081 }
16082 resultobj = SWIG_From_int(static_cast< int >(result));
16083 return resultobj;
16084 fail:
16085 return NULL;
16086 }
16087
16088
16089 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16090 PyObject *resultobj = 0;
16091 wxJoystick *arg1 = (wxJoystick *) 0 ;
16092 int result;
16093 void *argp1 = 0 ;
16094 int res1 = 0 ;
16095 PyObject *swig_obj[1] ;
16096
16097 if (!args) SWIG_fail;
16098 swig_obj[0] = args;
16099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16100 if (!SWIG_IsOK(res1)) {
16101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16102 }
16103 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16104 {
16105 PyThreadState* __tstate = wxPyBeginAllowThreads();
16106 result = (int)(arg1)->GetRudderMax();
16107 wxPyEndAllowThreads(__tstate);
16108 if (PyErr_Occurred()) SWIG_fail;
16109 }
16110 resultobj = SWIG_From_int(static_cast< int >(result));
16111 return resultobj;
16112 fail:
16113 return NULL;
16114 }
16115
16116
16117 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16118 PyObject *resultobj = 0;
16119 wxJoystick *arg1 = (wxJoystick *) 0 ;
16120 int result;
16121 void *argp1 = 0 ;
16122 int res1 = 0 ;
16123 PyObject *swig_obj[1] ;
16124
16125 if (!args) SWIG_fail;
16126 swig_obj[0] = args;
16127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16128 if (!SWIG_IsOK(res1)) {
16129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16130 }
16131 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16132 {
16133 PyThreadState* __tstate = wxPyBeginAllowThreads();
16134 result = (int)(arg1)->GetUMin();
16135 wxPyEndAllowThreads(__tstate);
16136 if (PyErr_Occurred()) SWIG_fail;
16137 }
16138 resultobj = SWIG_From_int(static_cast< int >(result));
16139 return resultobj;
16140 fail:
16141 return NULL;
16142 }
16143
16144
16145 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16146 PyObject *resultobj = 0;
16147 wxJoystick *arg1 = (wxJoystick *) 0 ;
16148 int result;
16149 void *argp1 = 0 ;
16150 int res1 = 0 ;
16151 PyObject *swig_obj[1] ;
16152
16153 if (!args) SWIG_fail;
16154 swig_obj[0] = args;
16155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16156 if (!SWIG_IsOK(res1)) {
16157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16158 }
16159 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16160 {
16161 PyThreadState* __tstate = wxPyBeginAllowThreads();
16162 result = (int)(arg1)->GetUMax();
16163 wxPyEndAllowThreads(__tstate);
16164 if (PyErr_Occurred()) SWIG_fail;
16165 }
16166 resultobj = SWIG_From_int(static_cast< int >(result));
16167 return resultobj;
16168 fail:
16169 return NULL;
16170 }
16171
16172
16173 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16174 PyObject *resultobj = 0;
16175 wxJoystick *arg1 = (wxJoystick *) 0 ;
16176 int result;
16177 void *argp1 = 0 ;
16178 int res1 = 0 ;
16179 PyObject *swig_obj[1] ;
16180
16181 if (!args) SWIG_fail;
16182 swig_obj[0] = args;
16183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16184 if (!SWIG_IsOK(res1)) {
16185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16186 }
16187 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16188 {
16189 PyThreadState* __tstate = wxPyBeginAllowThreads();
16190 result = (int)(arg1)->GetVMin();
16191 wxPyEndAllowThreads(__tstate);
16192 if (PyErr_Occurred()) SWIG_fail;
16193 }
16194 resultobj = SWIG_From_int(static_cast< int >(result));
16195 return resultobj;
16196 fail:
16197 return NULL;
16198 }
16199
16200
16201 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16202 PyObject *resultobj = 0;
16203 wxJoystick *arg1 = (wxJoystick *) 0 ;
16204 int result;
16205 void *argp1 = 0 ;
16206 int res1 = 0 ;
16207 PyObject *swig_obj[1] ;
16208
16209 if (!args) SWIG_fail;
16210 swig_obj[0] = args;
16211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16212 if (!SWIG_IsOK(res1)) {
16213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16214 }
16215 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16216 {
16217 PyThreadState* __tstate = wxPyBeginAllowThreads();
16218 result = (int)(arg1)->GetVMax();
16219 wxPyEndAllowThreads(__tstate);
16220 if (PyErr_Occurred()) SWIG_fail;
16221 }
16222 resultobj = SWIG_From_int(static_cast< int >(result));
16223 return resultobj;
16224 fail:
16225 return NULL;
16226 }
16227
16228
16229 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16230 PyObject *resultobj = 0;
16231 wxJoystick *arg1 = (wxJoystick *) 0 ;
16232 bool result;
16233 void *argp1 = 0 ;
16234 int res1 = 0 ;
16235 PyObject *swig_obj[1] ;
16236
16237 if (!args) SWIG_fail;
16238 swig_obj[0] = args;
16239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16240 if (!SWIG_IsOK(res1)) {
16241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16242 }
16243 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16244 {
16245 PyThreadState* __tstate = wxPyBeginAllowThreads();
16246 result = (bool)(arg1)->HasRudder();
16247 wxPyEndAllowThreads(__tstate);
16248 if (PyErr_Occurred()) SWIG_fail;
16249 }
16250 {
16251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16252 }
16253 return resultobj;
16254 fail:
16255 return NULL;
16256 }
16257
16258
16259 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16260 PyObject *resultobj = 0;
16261 wxJoystick *arg1 = (wxJoystick *) 0 ;
16262 bool result;
16263 void *argp1 = 0 ;
16264 int res1 = 0 ;
16265 PyObject *swig_obj[1] ;
16266
16267 if (!args) SWIG_fail;
16268 swig_obj[0] = args;
16269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16270 if (!SWIG_IsOK(res1)) {
16271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16272 }
16273 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 result = (bool)(arg1)->HasZ();
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 {
16281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16282 }
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16290 PyObject *resultobj = 0;
16291 wxJoystick *arg1 = (wxJoystick *) 0 ;
16292 bool result;
16293 void *argp1 = 0 ;
16294 int res1 = 0 ;
16295 PyObject *swig_obj[1] ;
16296
16297 if (!args) SWIG_fail;
16298 swig_obj[0] = args;
16299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16300 if (!SWIG_IsOK(res1)) {
16301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16302 }
16303 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16304 {
16305 PyThreadState* __tstate = wxPyBeginAllowThreads();
16306 result = (bool)(arg1)->HasU();
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 {
16311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16312 }
16313 return resultobj;
16314 fail:
16315 return NULL;
16316 }
16317
16318
16319 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16320 PyObject *resultobj = 0;
16321 wxJoystick *arg1 = (wxJoystick *) 0 ;
16322 bool result;
16323 void *argp1 = 0 ;
16324 int res1 = 0 ;
16325 PyObject *swig_obj[1] ;
16326
16327 if (!args) SWIG_fail;
16328 swig_obj[0] = args;
16329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16330 if (!SWIG_IsOK(res1)) {
16331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16332 }
16333 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16334 {
16335 PyThreadState* __tstate = wxPyBeginAllowThreads();
16336 result = (bool)(arg1)->HasV();
16337 wxPyEndAllowThreads(__tstate);
16338 if (PyErr_Occurred()) SWIG_fail;
16339 }
16340 {
16341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16342 }
16343 return resultobj;
16344 fail:
16345 return NULL;
16346 }
16347
16348
16349 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16350 PyObject *resultobj = 0;
16351 wxJoystick *arg1 = (wxJoystick *) 0 ;
16352 bool result;
16353 void *argp1 = 0 ;
16354 int res1 = 0 ;
16355 PyObject *swig_obj[1] ;
16356
16357 if (!args) SWIG_fail;
16358 swig_obj[0] = args;
16359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16360 if (!SWIG_IsOK(res1)) {
16361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16362 }
16363 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16364 {
16365 PyThreadState* __tstate = wxPyBeginAllowThreads();
16366 result = (bool)(arg1)->HasPOV();
16367 wxPyEndAllowThreads(__tstate);
16368 if (PyErr_Occurred()) SWIG_fail;
16369 }
16370 {
16371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16372 }
16373 return resultobj;
16374 fail:
16375 return NULL;
16376 }
16377
16378
16379 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16380 PyObject *resultobj = 0;
16381 wxJoystick *arg1 = (wxJoystick *) 0 ;
16382 bool result;
16383 void *argp1 = 0 ;
16384 int res1 = 0 ;
16385 PyObject *swig_obj[1] ;
16386
16387 if (!args) SWIG_fail;
16388 swig_obj[0] = args;
16389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16390 if (!SWIG_IsOK(res1)) {
16391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16392 }
16393 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 result = (bool)(arg1)->HasPOV4Dir();
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 {
16401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16402 }
16403 return resultobj;
16404 fail:
16405 return NULL;
16406 }
16407
16408
16409 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16410 PyObject *resultobj = 0;
16411 wxJoystick *arg1 = (wxJoystick *) 0 ;
16412 bool result;
16413 void *argp1 = 0 ;
16414 int res1 = 0 ;
16415 PyObject *swig_obj[1] ;
16416
16417 if (!args) SWIG_fail;
16418 swig_obj[0] = args;
16419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16420 if (!SWIG_IsOK(res1)) {
16421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16422 }
16423 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16424 {
16425 PyThreadState* __tstate = wxPyBeginAllowThreads();
16426 result = (bool)(arg1)->HasPOVCTS();
16427 wxPyEndAllowThreads(__tstate);
16428 if (PyErr_Occurred()) SWIG_fail;
16429 }
16430 {
16431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16432 }
16433 return resultobj;
16434 fail:
16435 return NULL;
16436 }
16437
16438
16439 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16440 PyObject *resultobj = 0;
16441 wxJoystick *arg1 = (wxJoystick *) 0 ;
16442 wxWindow *arg2 = (wxWindow *) 0 ;
16443 int arg3 = (int) 0 ;
16444 bool result;
16445 void *argp1 = 0 ;
16446 int res1 = 0 ;
16447 void *argp2 = 0 ;
16448 int res2 = 0 ;
16449 int val3 ;
16450 int ecode3 = 0 ;
16451 PyObject * obj0 = 0 ;
16452 PyObject * obj1 = 0 ;
16453 PyObject * obj2 = 0 ;
16454 char * kwnames[] = {
16455 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16456 };
16457
16458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16460 if (!SWIG_IsOK(res1)) {
16461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16462 }
16463 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16465 if (!SWIG_IsOK(res2)) {
16466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16467 }
16468 arg2 = reinterpret_cast< wxWindow * >(argp2);
16469 if (obj2) {
16470 ecode3 = SWIG_AsVal_int(obj2, &val3);
16471 if (!SWIG_IsOK(ecode3)) {
16472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16473 }
16474 arg3 = static_cast< int >(val3);
16475 }
16476 {
16477 PyThreadState* __tstate = wxPyBeginAllowThreads();
16478 result = (bool)(arg1)->SetCapture(arg2,arg3);
16479 wxPyEndAllowThreads(__tstate);
16480 if (PyErr_Occurred()) SWIG_fail;
16481 }
16482 {
16483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16484 }
16485 return resultobj;
16486 fail:
16487 return NULL;
16488 }
16489
16490
16491 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16492 PyObject *resultobj = 0;
16493 wxJoystick *arg1 = (wxJoystick *) 0 ;
16494 bool result;
16495 void *argp1 = 0 ;
16496 int res1 = 0 ;
16497 PyObject *swig_obj[1] ;
16498
16499 if (!args) SWIG_fail;
16500 swig_obj[0] = args;
16501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16502 if (!SWIG_IsOK(res1)) {
16503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16504 }
16505 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16506 {
16507 PyThreadState* __tstate = wxPyBeginAllowThreads();
16508 result = (bool)(arg1)->ReleaseCapture();
16509 wxPyEndAllowThreads(__tstate);
16510 if (PyErr_Occurred()) SWIG_fail;
16511 }
16512 {
16513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16514 }
16515 return resultobj;
16516 fail:
16517 return NULL;
16518 }
16519
16520
16521 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16522 PyObject *obj;
16523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16524 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16525 return SWIG_Py_Void();
16526 }
16527
16528 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16529 return SWIG_Python_InitShadowInstance(args);
16530 }
16531
16532 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16533 PyObject *resultobj = 0;
16534 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16535 int arg2 = (int) 0 ;
16536 int arg3 = (int) wxJOYSTICK1 ;
16537 int arg4 = (int) 0 ;
16538 wxJoystickEvent *result = 0 ;
16539 int val1 ;
16540 int ecode1 = 0 ;
16541 int val2 ;
16542 int ecode2 = 0 ;
16543 int val3 ;
16544 int ecode3 = 0 ;
16545 int val4 ;
16546 int ecode4 = 0 ;
16547 PyObject * obj0 = 0 ;
16548 PyObject * obj1 = 0 ;
16549 PyObject * obj2 = 0 ;
16550 PyObject * obj3 = 0 ;
16551 char * kwnames[] = {
16552 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16553 };
16554
16555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16556 if (obj0) {
16557 ecode1 = SWIG_AsVal_int(obj0, &val1);
16558 if (!SWIG_IsOK(ecode1)) {
16559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16560 }
16561 arg1 = static_cast< wxEventType >(val1);
16562 }
16563 if (obj1) {
16564 ecode2 = SWIG_AsVal_int(obj1, &val2);
16565 if (!SWIG_IsOK(ecode2)) {
16566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16567 }
16568 arg2 = static_cast< int >(val2);
16569 }
16570 if (obj2) {
16571 ecode3 = SWIG_AsVal_int(obj2, &val3);
16572 if (!SWIG_IsOK(ecode3)) {
16573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16574 }
16575 arg3 = static_cast< int >(val3);
16576 }
16577 if (obj3) {
16578 ecode4 = SWIG_AsVal_int(obj3, &val4);
16579 if (!SWIG_IsOK(ecode4)) {
16580 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16581 }
16582 arg4 = static_cast< int >(val4);
16583 }
16584 {
16585 PyThreadState* __tstate = wxPyBeginAllowThreads();
16586 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16587 wxPyEndAllowThreads(__tstate);
16588 if (PyErr_Occurred()) SWIG_fail;
16589 }
16590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16591 return resultobj;
16592 fail:
16593 return NULL;
16594 }
16595
16596
16597 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16598 PyObject *resultobj = 0;
16599 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16600 wxPoint result;
16601 void *argp1 = 0 ;
16602 int res1 = 0 ;
16603 PyObject *swig_obj[1] ;
16604
16605 if (!args) SWIG_fail;
16606 swig_obj[0] = args;
16607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16608 if (!SWIG_IsOK(res1)) {
16609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16610 }
16611 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16612 {
16613 PyThreadState* __tstate = wxPyBeginAllowThreads();
16614 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16615 wxPyEndAllowThreads(__tstate);
16616 if (PyErr_Occurred()) SWIG_fail;
16617 }
16618 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16619 return resultobj;
16620 fail:
16621 return NULL;
16622 }
16623
16624
16625 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16626 PyObject *resultobj = 0;
16627 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16628 int result;
16629 void *argp1 = 0 ;
16630 int res1 = 0 ;
16631 PyObject *swig_obj[1] ;
16632
16633 if (!args) SWIG_fail;
16634 swig_obj[0] = args;
16635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16636 if (!SWIG_IsOK(res1)) {
16637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16638 }
16639 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16640 {
16641 PyThreadState* __tstate = wxPyBeginAllowThreads();
16642 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16643 wxPyEndAllowThreads(__tstate);
16644 if (PyErr_Occurred()) SWIG_fail;
16645 }
16646 resultobj = SWIG_From_int(static_cast< int >(result));
16647 return resultobj;
16648 fail:
16649 return NULL;
16650 }
16651
16652
16653 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16654 PyObject *resultobj = 0;
16655 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16656 int result;
16657 void *argp1 = 0 ;
16658 int res1 = 0 ;
16659 PyObject *swig_obj[1] ;
16660
16661 if (!args) SWIG_fail;
16662 swig_obj[0] = args;
16663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16664 if (!SWIG_IsOK(res1)) {
16665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16666 }
16667 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16668 {
16669 PyThreadState* __tstate = wxPyBeginAllowThreads();
16670 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16671 wxPyEndAllowThreads(__tstate);
16672 if (PyErr_Occurred()) SWIG_fail;
16673 }
16674 resultobj = SWIG_From_int(static_cast< int >(result));
16675 return resultobj;
16676 fail:
16677 return NULL;
16678 }
16679
16680
16681 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16682 PyObject *resultobj = 0;
16683 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16684 int result;
16685 void *argp1 = 0 ;
16686 int res1 = 0 ;
16687 PyObject *swig_obj[1] ;
16688
16689 if (!args) SWIG_fail;
16690 swig_obj[0] = args;
16691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16692 if (!SWIG_IsOK(res1)) {
16693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16694 }
16695 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16696 {
16697 PyThreadState* __tstate = wxPyBeginAllowThreads();
16698 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 resultobj = SWIG_From_int(static_cast< int >(result));
16703 return resultobj;
16704 fail:
16705 return NULL;
16706 }
16707
16708
16709 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16710 PyObject *resultobj = 0;
16711 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16712 int result;
16713 void *argp1 = 0 ;
16714 int res1 = 0 ;
16715 PyObject *swig_obj[1] ;
16716
16717 if (!args) SWIG_fail;
16718 swig_obj[0] = args;
16719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16722 }
16723 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16724 {
16725 PyThreadState* __tstate = wxPyBeginAllowThreads();
16726 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16727 wxPyEndAllowThreads(__tstate);
16728 if (PyErr_Occurred()) SWIG_fail;
16729 }
16730 resultobj = SWIG_From_int(static_cast< int >(result));
16731 return resultobj;
16732 fail:
16733 return NULL;
16734 }
16735
16736
16737 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16738 PyObject *resultobj = 0;
16739 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16740 int arg2 ;
16741 void *argp1 = 0 ;
16742 int res1 = 0 ;
16743 int val2 ;
16744 int ecode2 = 0 ;
16745 PyObject * obj0 = 0 ;
16746 PyObject * obj1 = 0 ;
16747 char * kwnames[] = {
16748 (char *) "self",(char *) "stick", NULL
16749 };
16750
16751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16753 if (!SWIG_IsOK(res1)) {
16754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16755 }
16756 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16757 ecode2 = SWIG_AsVal_int(obj1, &val2);
16758 if (!SWIG_IsOK(ecode2)) {
16759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16760 }
16761 arg2 = static_cast< int >(val2);
16762 {
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 (arg1)->SetJoystick(arg2);
16765 wxPyEndAllowThreads(__tstate);
16766 if (PyErr_Occurred()) SWIG_fail;
16767 }
16768 resultobj = SWIG_Py_Void();
16769 return resultobj;
16770 fail:
16771 return NULL;
16772 }
16773
16774
16775 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16776 PyObject *resultobj = 0;
16777 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16778 int arg2 ;
16779 void *argp1 = 0 ;
16780 int res1 = 0 ;
16781 int val2 ;
16782 int ecode2 = 0 ;
16783 PyObject * obj0 = 0 ;
16784 PyObject * obj1 = 0 ;
16785 char * kwnames[] = {
16786 (char *) "self",(char *) "state", NULL
16787 };
16788
16789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16791 if (!SWIG_IsOK(res1)) {
16792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16793 }
16794 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16795 ecode2 = SWIG_AsVal_int(obj1, &val2);
16796 if (!SWIG_IsOK(ecode2)) {
16797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16798 }
16799 arg2 = static_cast< int >(val2);
16800 {
16801 PyThreadState* __tstate = wxPyBeginAllowThreads();
16802 (arg1)->SetButtonState(arg2);
16803 wxPyEndAllowThreads(__tstate);
16804 if (PyErr_Occurred()) SWIG_fail;
16805 }
16806 resultobj = SWIG_Py_Void();
16807 return resultobj;
16808 fail:
16809 return NULL;
16810 }
16811
16812
16813 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16814 PyObject *resultobj = 0;
16815 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16816 int arg2 ;
16817 void *argp1 = 0 ;
16818 int res1 = 0 ;
16819 int val2 ;
16820 int ecode2 = 0 ;
16821 PyObject * obj0 = 0 ;
16822 PyObject * obj1 = 0 ;
16823 char * kwnames[] = {
16824 (char *) "self",(char *) "change", NULL
16825 };
16826
16827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16829 if (!SWIG_IsOK(res1)) {
16830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16831 }
16832 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16833 ecode2 = SWIG_AsVal_int(obj1, &val2);
16834 if (!SWIG_IsOK(ecode2)) {
16835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16836 }
16837 arg2 = static_cast< int >(val2);
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 (arg1)->SetButtonChange(arg2);
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = SWIG_Py_Void();
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj = 0;
16853 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16854 wxPoint *arg2 = 0 ;
16855 void *argp1 = 0 ;
16856 int res1 = 0 ;
16857 wxPoint temp2 ;
16858 PyObject * obj0 = 0 ;
16859 PyObject * obj1 = 0 ;
16860 char * kwnames[] = {
16861 (char *) "self",(char *) "pos", NULL
16862 };
16863
16864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16866 if (!SWIG_IsOK(res1)) {
16867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16868 }
16869 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16870 {
16871 arg2 = &temp2;
16872 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16873 }
16874 {
16875 PyThreadState* __tstate = wxPyBeginAllowThreads();
16876 (arg1)->SetPosition((wxPoint const &)*arg2);
16877 wxPyEndAllowThreads(__tstate);
16878 if (PyErr_Occurred()) SWIG_fail;
16879 }
16880 resultobj = SWIG_Py_Void();
16881 return resultobj;
16882 fail:
16883 return NULL;
16884 }
16885
16886
16887 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16888 PyObject *resultobj = 0;
16889 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16890 int arg2 ;
16891 void *argp1 = 0 ;
16892 int res1 = 0 ;
16893 int val2 ;
16894 int ecode2 = 0 ;
16895 PyObject * obj0 = 0 ;
16896 PyObject * obj1 = 0 ;
16897 char * kwnames[] = {
16898 (char *) "self",(char *) "zPos", NULL
16899 };
16900
16901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16903 if (!SWIG_IsOK(res1)) {
16904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16905 }
16906 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16907 ecode2 = SWIG_AsVal_int(obj1, &val2);
16908 if (!SWIG_IsOK(ecode2)) {
16909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16910 }
16911 arg2 = static_cast< int >(val2);
16912 {
16913 PyThreadState* __tstate = wxPyBeginAllowThreads();
16914 (arg1)->SetZPosition(arg2);
16915 wxPyEndAllowThreads(__tstate);
16916 if (PyErr_Occurred()) SWIG_fail;
16917 }
16918 resultobj = SWIG_Py_Void();
16919 return resultobj;
16920 fail:
16921 return NULL;
16922 }
16923
16924
16925 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16926 PyObject *resultobj = 0;
16927 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16928 bool result;
16929 void *argp1 = 0 ;
16930 int res1 = 0 ;
16931 PyObject *swig_obj[1] ;
16932
16933 if (!args) SWIG_fail;
16934 swig_obj[0] = args;
16935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16936 if (!SWIG_IsOK(res1)) {
16937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16938 }
16939 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16940 {
16941 PyThreadState* __tstate = wxPyBeginAllowThreads();
16942 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16943 wxPyEndAllowThreads(__tstate);
16944 if (PyErr_Occurred()) SWIG_fail;
16945 }
16946 {
16947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16948 }
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16956 PyObject *resultobj = 0;
16957 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16958 bool result;
16959 void *argp1 = 0 ;
16960 int res1 = 0 ;
16961 PyObject *swig_obj[1] ;
16962
16963 if (!args) SWIG_fail;
16964 swig_obj[0] = args;
16965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16966 if (!SWIG_IsOK(res1)) {
16967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16968 }
16969 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16973 wxPyEndAllowThreads(__tstate);
16974 if (PyErr_Occurred()) SWIG_fail;
16975 }
16976 {
16977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16978 }
16979 return resultobj;
16980 fail:
16981 return NULL;
16982 }
16983
16984
16985 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16986 PyObject *resultobj = 0;
16987 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16988 bool result;
16989 void *argp1 = 0 ;
16990 int res1 = 0 ;
16991 PyObject *swig_obj[1] ;
16992
16993 if (!args) SWIG_fail;
16994 swig_obj[0] = args;
16995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16996 if (!SWIG_IsOK(res1)) {
16997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16998 }
16999 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
17003 wxPyEndAllowThreads(__tstate);
17004 if (PyErr_Occurred()) SWIG_fail;
17005 }
17006 {
17007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17008 }
17009 return resultobj;
17010 fail:
17011 return NULL;
17012 }
17013
17014
17015 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17016 PyObject *resultobj = 0;
17017 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17018 int arg2 = (int) wxJOY_BUTTON_ANY ;
17019 bool result;
17020 void *argp1 = 0 ;
17021 int res1 = 0 ;
17022 int val2 ;
17023 int ecode2 = 0 ;
17024 PyObject * obj0 = 0 ;
17025 PyObject * obj1 = 0 ;
17026 char * kwnames[] = {
17027 (char *) "self",(char *) "but", NULL
17028 };
17029
17030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17032 if (!SWIG_IsOK(res1)) {
17033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17034 }
17035 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17036 if (obj1) {
17037 ecode2 = SWIG_AsVal_int(obj1, &val2);
17038 if (!SWIG_IsOK(ecode2)) {
17039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17040 }
17041 arg2 = static_cast< int >(val2);
17042 }
17043 {
17044 PyThreadState* __tstate = wxPyBeginAllowThreads();
17045 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17046 wxPyEndAllowThreads(__tstate);
17047 if (PyErr_Occurred()) SWIG_fail;
17048 }
17049 {
17050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17051 }
17052 return resultobj;
17053 fail:
17054 return NULL;
17055 }
17056
17057
17058 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17059 PyObject *resultobj = 0;
17060 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17061 int arg2 = (int) wxJOY_BUTTON_ANY ;
17062 bool result;
17063 void *argp1 = 0 ;
17064 int res1 = 0 ;
17065 int val2 ;
17066 int ecode2 = 0 ;
17067 PyObject * obj0 = 0 ;
17068 PyObject * obj1 = 0 ;
17069 char * kwnames[] = {
17070 (char *) "self",(char *) "but", NULL
17071 };
17072
17073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17075 if (!SWIG_IsOK(res1)) {
17076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17077 }
17078 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17079 if (obj1) {
17080 ecode2 = SWIG_AsVal_int(obj1, &val2);
17081 if (!SWIG_IsOK(ecode2)) {
17082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17083 }
17084 arg2 = static_cast< int >(val2);
17085 }
17086 {
17087 PyThreadState* __tstate = wxPyBeginAllowThreads();
17088 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17089 wxPyEndAllowThreads(__tstate);
17090 if (PyErr_Occurred()) SWIG_fail;
17091 }
17092 {
17093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17094 }
17095 return resultobj;
17096 fail:
17097 return NULL;
17098 }
17099
17100
17101 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17102 PyObject *resultobj = 0;
17103 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17104 int arg2 = (int) wxJOY_BUTTON_ANY ;
17105 bool result;
17106 void *argp1 = 0 ;
17107 int res1 = 0 ;
17108 int val2 ;
17109 int ecode2 = 0 ;
17110 PyObject * obj0 = 0 ;
17111 PyObject * obj1 = 0 ;
17112 char * kwnames[] = {
17113 (char *) "self",(char *) "but", NULL
17114 };
17115
17116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17118 if (!SWIG_IsOK(res1)) {
17119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17120 }
17121 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17122 if (obj1) {
17123 ecode2 = SWIG_AsVal_int(obj1, &val2);
17124 if (!SWIG_IsOK(ecode2)) {
17125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17126 }
17127 arg2 = static_cast< int >(val2);
17128 }
17129 {
17130 PyThreadState* __tstate = wxPyBeginAllowThreads();
17131 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17132 wxPyEndAllowThreads(__tstate);
17133 if (PyErr_Occurred()) SWIG_fail;
17134 }
17135 {
17136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17137 }
17138 return resultobj;
17139 fail:
17140 return NULL;
17141 }
17142
17143
17144 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17145 PyObject *obj;
17146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17147 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17148 return SWIG_Py_Void();
17149 }
17150
17151 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17152 return SWIG_Python_InitShadowInstance(args);
17153 }
17154
17155 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17156 PyObject *resultobj = 0;
17157 wxString const &arg1_defvalue = wxPyEmptyString ;
17158 wxString *arg1 = (wxString *) &arg1_defvalue ;
17159 wxSound *result = 0 ;
17160 bool temp1 = false ;
17161 PyObject * obj0 = 0 ;
17162 char * kwnames[] = {
17163 (char *) "fileName", NULL
17164 };
17165
17166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17167 if (obj0) {
17168 {
17169 arg1 = wxString_in_helper(obj0);
17170 if (arg1 == NULL) SWIG_fail;
17171 temp1 = true;
17172 }
17173 }
17174 {
17175 if (!wxPyCheckForApp()) SWIG_fail;
17176 PyThreadState* __tstate = wxPyBeginAllowThreads();
17177 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17178 wxPyEndAllowThreads(__tstate);
17179 if (PyErr_Occurred()) SWIG_fail;
17180 }
17181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17182 {
17183 if (temp1)
17184 delete arg1;
17185 }
17186 return resultobj;
17187 fail:
17188 {
17189 if (temp1)
17190 delete arg1;
17191 }
17192 return NULL;
17193 }
17194
17195
17196 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17197 PyObject *resultobj = 0;
17198 PyObject *arg1 = (PyObject *) 0 ;
17199 wxSound *result = 0 ;
17200 PyObject * obj0 = 0 ;
17201 char * kwnames[] = {
17202 (char *) "data", NULL
17203 };
17204
17205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17206 arg1 = obj0;
17207 {
17208 if (!wxPyCheckForApp()) SWIG_fail;
17209 PyThreadState* __tstate = wxPyBeginAllowThreads();
17210 result = (wxSound *)new_wxSound(arg1);
17211 wxPyEndAllowThreads(__tstate);
17212 if (PyErr_Occurred()) SWIG_fail;
17213 }
17214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17215 return resultobj;
17216 fail:
17217 return NULL;
17218 }
17219
17220
17221 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17222 PyObject *resultobj = 0;
17223 wxSound *arg1 = (wxSound *) 0 ;
17224 void *argp1 = 0 ;
17225 int res1 = 0 ;
17226 PyObject *swig_obj[1] ;
17227
17228 if (!args) SWIG_fail;
17229 swig_obj[0] = args;
17230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17231 if (!SWIG_IsOK(res1)) {
17232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17233 }
17234 arg1 = reinterpret_cast< wxSound * >(argp1);
17235 {
17236 PyThreadState* __tstate = wxPyBeginAllowThreads();
17237 delete arg1;
17238
17239 wxPyEndAllowThreads(__tstate);
17240 if (PyErr_Occurred()) SWIG_fail;
17241 }
17242 resultobj = SWIG_Py_Void();
17243 return resultobj;
17244 fail:
17245 return NULL;
17246 }
17247
17248
17249 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17250 PyObject *resultobj = 0;
17251 wxSound *arg1 = (wxSound *) 0 ;
17252 wxString *arg2 = 0 ;
17253 bool result;
17254 void *argp1 = 0 ;
17255 int res1 = 0 ;
17256 bool temp2 = false ;
17257 PyObject * obj0 = 0 ;
17258 PyObject * obj1 = 0 ;
17259 char * kwnames[] = {
17260 (char *) "self",(char *) "fileName", NULL
17261 };
17262
17263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17265 if (!SWIG_IsOK(res1)) {
17266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17267 }
17268 arg1 = reinterpret_cast< wxSound * >(argp1);
17269 {
17270 arg2 = wxString_in_helper(obj1);
17271 if (arg2 == NULL) SWIG_fail;
17272 temp2 = true;
17273 }
17274 {
17275 PyThreadState* __tstate = wxPyBeginAllowThreads();
17276 result = (bool)(arg1)->Create((wxString const &)*arg2);
17277 wxPyEndAllowThreads(__tstate);
17278 if (PyErr_Occurred()) SWIG_fail;
17279 }
17280 {
17281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17282 }
17283 {
17284 if (temp2)
17285 delete arg2;
17286 }
17287 return resultobj;
17288 fail:
17289 {
17290 if (temp2)
17291 delete arg2;
17292 }
17293 return NULL;
17294 }
17295
17296
17297 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17298 PyObject *resultobj = 0;
17299 wxSound *arg1 = (wxSound *) 0 ;
17300 PyObject *arg2 = (PyObject *) 0 ;
17301 bool result;
17302 void *argp1 = 0 ;
17303 int res1 = 0 ;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 char * kwnames[] = {
17307 (char *) "self",(char *) "data", NULL
17308 };
17309
17310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17312 if (!SWIG_IsOK(res1)) {
17313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17314 }
17315 arg1 = reinterpret_cast< wxSound * >(argp1);
17316 arg2 = obj1;
17317 {
17318 PyThreadState* __tstate = wxPyBeginAllowThreads();
17319 result = (bool)wxSound_CreateFromData(arg1,arg2);
17320 wxPyEndAllowThreads(__tstate);
17321 if (PyErr_Occurred()) SWIG_fail;
17322 }
17323 {
17324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17325 }
17326 return resultobj;
17327 fail:
17328 return NULL;
17329 }
17330
17331
17332 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17333 PyObject *resultobj = 0;
17334 wxSound *arg1 = (wxSound *) 0 ;
17335 bool result;
17336 void *argp1 = 0 ;
17337 int res1 = 0 ;
17338 PyObject *swig_obj[1] ;
17339
17340 if (!args) SWIG_fail;
17341 swig_obj[0] = args;
17342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17343 if (!SWIG_IsOK(res1)) {
17344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17345 }
17346 arg1 = reinterpret_cast< wxSound * >(argp1);
17347 {
17348 PyThreadState* __tstate = wxPyBeginAllowThreads();
17349 result = (bool)(arg1)->IsOk();
17350 wxPyEndAllowThreads(__tstate);
17351 if (PyErr_Occurred()) SWIG_fail;
17352 }
17353 {
17354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17355 }
17356 return resultobj;
17357 fail:
17358 return NULL;
17359 }
17360
17361
17362 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17363 PyObject *resultobj = 0;
17364 wxSound *arg1 = (wxSound *) 0 ;
17365 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17366 bool result;
17367 void *argp1 = 0 ;
17368 int res1 = 0 ;
17369 unsigned int val2 ;
17370 int ecode2 = 0 ;
17371 PyObject * obj0 = 0 ;
17372 PyObject * obj1 = 0 ;
17373 char * kwnames[] = {
17374 (char *) "self",(char *) "flags", NULL
17375 };
17376
17377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17379 if (!SWIG_IsOK(res1)) {
17380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17381 }
17382 arg1 = reinterpret_cast< wxSound * >(argp1);
17383 if (obj1) {
17384 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17385 if (!SWIG_IsOK(ecode2)) {
17386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17387 }
17388 arg2 = static_cast< unsigned int >(val2);
17389 }
17390 {
17391 if (!wxPyCheckForApp()) SWIG_fail;
17392 PyThreadState* __tstate = wxPyBeginAllowThreads();
17393 result = (bool)((wxSound const *)arg1)->Play(arg2);
17394 wxPyEndAllowThreads(__tstate);
17395 if (PyErr_Occurred()) SWIG_fail;
17396 }
17397 {
17398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17399 }
17400 return resultobj;
17401 fail:
17402 return NULL;
17403 }
17404
17405
17406 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17407 PyObject *resultobj = 0;
17408 wxString *arg1 = 0 ;
17409 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17410 bool result;
17411 bool temp1 = false ;
17412 unsigned int val2 ;
17413 int ecode2 = 0 ;
17414 PyObject * obj0 = 0 ;
17415 PyObject * obj1 = 0 ;
17416 char * kwnames[] = {
17417 (char *) "filename",(char *) "flags", NULL
17418 };
17419
17420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17421 {
17422 arg1 = wxString_in_helper(obj0);
17423 if (arg1 == NULL) SWIG_fail;
17424 temp1 = true;
17425 }
17426 if (obj1) {
17427 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17428 if (!SWIG_IsOK(ecode2)) {
17429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17430 }
17431 arg2 = static_cast< unsigned int >(val2);
17432 }
17433 {
17434 if (!wxPyCheckForApp()) SWIG_fail;
17435 PyThreadState* __tstate = wxPyBeginAllowThreads();
17436 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17437 wxPyEndAllowThreads(__tstate);
17438 if (PyErr_Occurred()) SWIG_fail;
17439 }
17440 {
17441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17442 }
17443 {
17444 if (temp1)
17445 delete arg1;
17446 }
17447 return resultobj;
17448 fail:
17449 {
17450 if (temp1)
17451 delete arg1;
17452 }
17453 return NULL;
17454 }
17455
17456
17457 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17458 PyObject *resultobj = 0;
17459
17460 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17461 {
17462 if (!wxPyCheckForApp()) SWIG_fail;
17463 PyThreadState* __tstate = wxPyBeginAllowThreads();
17464 wxSound::Stop();
17465 wxPyEndAllowThreads(__tstate);
17466 if (PyErr_Occurred()) SWIG_fail;
17467 }
17468 resultobj = SWIG_Py_Void();
17469 return resultobj;
17470 fail:
17471 return NULL;
17472 }
17473
17474
17475 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17476 PyObject *obj;
17477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17478 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17479 return SWIG_Py_Void();
17480 }
17481
17482 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17483 return SWIG_Python_InitShadowInstance(args);
17484 }
17485
17486 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17487 PyObject *resultobj = 0;
17488 wxString *arg1 = 0 ;
17489 wxString *arg2 = 0 ;
17490 wxString *arg3 = 0 ;
17491 wxString *arg4 = 0 ;
17492 wxFileTypeInfo *result = 0 ;
17493 bool temp1 = false ;
17494 bool temp2 = false ;
17495 bool temp3 = false ;
17496 bool temp4 = false ;
17497 PyObject * obj0 = 0 ;
17498 PyObject * obj1 = 0 ;
17499 PyObject * obj2 = 0 ;
17500 PyObject * obj3 = 0 ;
17501 char * kwnames[] = {
17502 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17503 };
17504
17505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17506 {
17507 arg1 = wxString_in_helper(obj0);
17508 if (arg1 == NULL) SWIG_fail;
17509 temp1 = true;
17510 }
17511 {
17512 arg2 = wxString_in_helper(obj1);
17513 if (arg2 == NULL) SWIG_fail;
17514 temp2 = true;
17515 }
17516 {
17517 arg3 = wxString_in_helper(obj2);
17518 if (arg3 == NULL) SWIG_fail;
17519 temp3 = true;
17520 }
17521 {
17522 arg4 = wxString_in_helper(obj3);
17523 if (arg4 == NULL) SWIG_fail;
17524 temp4 = true;
17525 }
17526 {
17527 PyThreadState* __tstate = wxPyBeginAllowThreads();
17528 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17529 wxPyEndAllowThreads(__tstate);
17530 if (PyErr_Occurred()) SWIG_fail;
17531 }
17532 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17533 {
17534 if (temp1)
17535 delete arg1;
17536 }
17537 {
17538 if (temp2)
17539 delete arg2;
17540 }
17541 {
17542 if (temp3)
17543 delete arg3;
17544 }
17545 {
17546 if (temp4)
17547 delete arg4;
17548 }
17549 return resultobj;
17550 fail:
17551 {
17552 if (temp1)
17553 delete arg1;
17554 }
17555 {
17556 if (temp2)
17557 delete arg2;
17558 }
17559 {
17560 if (temp3)
17561 delete arg3;
17562 }
17563 {
17564 if (temp4)
17565 delete arg4;
17566 }
17567 return NULL;
17568 }
17569
17570
17571 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj = 0;
17573 wxArrayString *arg1 = 0 ;
17574 wxFileTypeInfo *result = 0 ;
17575 bool temp1 = false ;
17576 PyObject * obj0 = 0 ;
17577 char * kwnames[] = {
17578 (char *) "sArray", NULL
17579 };
17580
17581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17582 {
17583 if (! PySequence_Check(obj0)) {
17584 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17585 SWIG_fail;
17586 }
17587 arg1 = new wxArrayString;
17588 temp1 = true;
17589 int i, len=PySequence_Length(obj0);
17590 for (i=0; i<len; i++) {
17591 PyObject* item = PySequence_GetItem(obj0, i);
17592 wxString* s = wxString_in_helper(item);
17593 if (PyErr_Occurred()) SWIG_fail;
17594 arg1->Add(*s);
17595 delete s;
17596 Py_DECREF(item);
17597 }
17598 }
17599 {
17600 PyThreadState* __tstate = wxPyBeginAllowThreads();
17601 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17602 wxPyEndAllowThreads(__tstate);
17603 if (PyErr_Occurred()) SWIG_fail;
17604 }
17605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17606 {
17607 if (temp1) delete arg1;
17608 }
17609 return resultobj;
17610 fail:
17611 {
17612 if (temp1) delete arg1;
17613 }
17614 return NULL;
17615 }
17616
17617
17618 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17619 PyObject *resultobj = 0;
17620 wxFileTypeInfo *result = 0 ;
17621
17622 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17637 PyObject *resultobj = 0;
17638 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17639 bool result;
17640 void *argp1 = 0 ;
17641 int res1 = 0 ;
17642 PyObject *swig_obj[1] ;
17643
17644 if (!args) SWIG_fail;
17645 swig_obj[0] = args;
17646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17647 if (!SWIG_IsOK(res1)) {
17648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17649 }
17650 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 {
17658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17659 }
17660 return resultobj;
17661 fail:
17662 return NULL;
17663 }
17664
17665
17666 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17667 PyObject *resultobj = 0;
17668 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17669 wxString *arg2 = 0 ;
17670 int arg3 = (int) 0 ;
17671 void *argp1 = 0 ;
17672 int res1 = 0 ;
17673 bool temp2 = false ;
17674 int val3 ;
17675 int ecode3 = 0 ;
17676 PyObject * obj0 = 0 ;
17677 PyObject * obj1 = 0 ;
17678 PyObject * obj2 = 0 ;
17679 char * kwnames[] = {
17680 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17681 };
17682
17683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17685 if (!SWIG_IsOK(res1)) {
17686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17687 }
17688 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17689 {
17690 arg2 = wxString_in_helper(obj1);
17691 if (arg2 == NULL) SWIG_fail;
17692 temp2 = true;
17693 }
17694 if (obj2) {
17695 ecode3 = SWIG_AsVal_int(obj2, &val3);
17696 if (!SWIG_IsOK(ecode3)) {
17697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17698 }
17699 arg3 = static_cast< int >(val3);
17700 }
17701 {
17702 PyThreadState* __tstate = wxPyBeginAllowThreads();
17703 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17704 wxPyEndAllowThreads(__tstate);
17705 if (PyErr_Occurred()) SWIG_fail;
17706 }
17707 resultobj = SWIG_Py_Void();
17708 {
17709 if (temp2)
17710 delete arg2;
17711 }
17712 return resultobj;
17713 fail:
17714 {
17715 if (temp2)
17716 delete arg2;
17717 }
17718 return NULL;
17719 }
17720
17721
17722 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17723 PyObject *resultobj = 0;
17724 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17725 wxString *arg2 = 0 ;
17726 void *argp1 = 0 ;
17727 int res1 = 0 ;
17728 bool temp2 = false ;
17729 PyObject * obj0 = 0 ;
17730 PyObject * obj1 = 0 ;
17731 char * kwnames[] = {
17732 (char *) "self",(char *) "shortDesc", NULL
17733 };
17734
17735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17737 if (!SWIG_IsOK(res1)) {
17738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17739 }
17740 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17741 {
17742 arg2 = wxString_in_helper(obj1);
17743 if (arg2 == NULL) SWIG_fail;
17744 temp2 = true;
17745 }
17746 {
17747 PyThreadState* __tstate = wxPyBeginAllowThreads();
17748 (arg1)->SetShortDesc((wxString const &)*arg2);
17749 wxPyEndAllowThreads(__tstate);
17750 if (PyErr_Occurred()) SWIG_fail;
17751 }
17752 resultobj = SWIG_Py_Void();
17753 {
17754 if (temp2)
17755 delete arg2;
17756 }
17757 return resultobj;
17758 fail:
17759 {
17760 if (temp2)
17761 delete arg2;
17762 }
17763 return NULL;
17764 }
17765
17766
17767 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17768 PyObject *resultobj = 0;
17769 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17770 wxString *result = 0 ;
17771 void *argp1 = 0 ;
17772 int res1 = 0 ;
17773 PyObject *swig_obj[1] ;
17774
17775 if (!args) SWIG_fail;
17776 swig_obj[0] = args;
17777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17778 if (!SWIG_IsOK(res1)) {
17779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17780 }
17781 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17782 {
17783 PyThreadState* __tstate = wxPyBeginAllowThreads();
17784 {
17785 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17786 result = (wxString *) &_result_ref;
17787 }
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 {
17792 #if wxUSE_UNICODE
17793 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17794 #else
17795 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17796 #endif
17797 }
17798 return resultobj;
17799 fail:
17800 return NULL;
17801 }
17802
17803
17804 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17805 PyObject *resultobj = 0;
17806 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17807 wxString *result = 0 ;
17808 void *argp1 = 0 ;
17809 int res1 = 0 ;
17810 PyObject *swig_obj[1] ;
17811
17812 if (!args) SWIG_fail;
17813 swig_obj[0] = args;
17814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17815 if (!SWIG_IsOK(res1)) {
17816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17817 }
17818 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17819 {
17820 PyThreadState* __tstate = wxPyBeginAllowThreads();
17821 {
17822 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17823 result = (wxString *) &_result_ref;
17824 }
17825 wxPyEndAllowThreads(__tstate);
17826 if (PyErr_Occurred()) SWIG_fail;
17827 }
17828 {
17829 #if wxUSE_UNICODE
17830 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17831 #else
17832 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17833 #endif
17834 }
17835 return resultobj;
17836 fail:
17837 return NULL;
17838 }
17839
17840
17841 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17842 PyObject *resultobj = 0;
17843 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17844 wxString *result = 0 ;
17845 void *argp1 = 0 ;
17846 int res1 = 0 ;
17847 PyObject *swig_obj[1] ;
17848
17849 if (!args) SWIG_fail;
17850 swig_obj[0] = args;
17851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17852 if (!SWIG_IsOK(res1)) {
17853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17854 }
17855 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17856 {
17857 PyThreadState* __tstate = wxPyBeginAllowThreads();
17858 {
17859 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17860 result = (wxString *) &_result_ref;
17861 }
17862 wxPyEndAllowThreads(__tstate);
17863 if (PyErr_Occurred()) SWIG_fail;
17864 }
17865 {
17866 #if wxUSE_UNICODE
17867 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17868 #else
17869 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17870 #endif
17871 }
17872 return resultobj;
17873 fail:
17874 return NULL;
17875 }
17876
17877
17878 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17879 PyObject *resultobj = 0;
17880 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17881 wxString *result = 0 ;
17882 void *argp1 = 0 ;
17883 int res1 = 0 ;
17884 PyObject *swig_obj[1] ;
17885
17886 if (!args) SWIG_fail;
17887 swig_obj[0] = args;
17888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17889 if (!SWIG_IsOK(res1)) {
17890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17891 }
17892 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17893 {
17894 PyThreadState* __tstate = wxPyBeginAllowThreads();
17895 {
17896 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17897 result = (wxString *) &_result_ref;
17898 }
17899 wxPyEndAllowThreads(__tstate);
17900 if (PyErr_Occurred()) SWIG_fail;
17901 }
17902 {
17903 #if wxUSE_UNICODE
17904 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17905 #else
17906 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17907 #endif
17908 }
17909 return resultobj;
17910 fail:
17911 return NULL;
17912 }
17913
17914
17915 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17916 PyObject *resultobj = 0;
17917 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17918 wxString *result = 0 ;
17919 void *argp1 = 0 ;
17920 int res1 = 0 ;
17921 PyObject *swig_obj[1] ;
17922
17923 if (!args) SWIG_fail;
17924 swig_obj[0] = args;
17925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17926 if (!SWIG_IsOK(res1)) {
17927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17928 }
17929 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 {
17933 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17934 result = (wxString *) &_result_ref;
17935 }
17936 wxPyEndAllowThreads(__tstate);
17937 if (PyErr_Occurred()) SWIG_fail;
17938 }
17939 {
17940 #if wxUSE_UNICODE
17941 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17942 #else
17943 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17944 #endif
17945 }
17946 return resultobj;
17947 fail:
17948 return NULL;
17949 }
17950
17951
17952 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17953 PyObject *resultobj = 0;
17954 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17955 wxArrayString *result = 0 ;
17956 void *argp1 = 0 ;
17957 int res1 = 0 ;
17958 PyObject *swig_obj[1] ;
17959
17960 if (!args) SWIG_fail;
17961 swig_obj[0] = args;
17962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17963 if (!SWIG_IsOK(res1)) {
17964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17965 }
17966 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17967 {
17968 PyThreadState* __tstate = wxPyBeginAllowThreads();
17969 {
17970 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17971 result = (wxArrayString *) &_result_ref;
17972 }
17973 wxPyEndAllowThreads(__tstate);
17974 if (PyErr_Occurred()) SWIG_fail;
17975 }
17976 {
17977 resultobj = wxArrayString2PyList_helper(*result);
17978 }
17979 return resultobj;
17980 fail:
17981 return NULL;
17982 }
17983
17984
17985 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17986 PyObject *resultobj = 0;
17987 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17988 size_t result;
17989 void *argp1 = 0 ;
17990 int res1 = 0 ;
17991 PyObject *swig_obj[1] ;
17992
17993 if (!args) SWIG_fail;
17994 swig_obj[0] = args;
17995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17996 if (!SWIG_IsOK(res1)) {
17997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17998 }
17999 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18000 {
18001 PyThreadState* __tstate = wxPyBeginAllowThreads();
18002 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
18003 wxPyEndAllowThreads(__tstate);
18004 if (PyErr_Occurred()) SWIG_fail;
18005 }
18006 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18007 return resultobj;
18008 fail:
18009 return NULL;
18010 }
18011
18012
18013 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18014 PyObject *resultobj = 0;
18015 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18016 wxString *result = 0 ;
18017 void *argp1 = 0 ;
18018 int res1 = 0 ;
18019 PyObject *swig_obj[1] ;
18020
18021 if (!args) SWIG_fail;
18022 swig_obj[0] = args;
18023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18024 if (!SWIG_IsOK(res1)) {
18025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18026 }
18027 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18028 {
18029 PyThreadState* __tstate = wxPyBeginAllowThreads();
18030 {
18031 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18032 result = (wxString *) &_result_ref;
18033 }
18034 wxPyEndAllowThreads(__tstate);
18035 if (PyErr_Occurred()) SWIG_fail;
18036 }
18037 {
18038 #if wxUSE_UNICODE
18039 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18040 #else
18041 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18042 #endif
18043 }
18044 return resultobj;
18045 fail:
18046 return NULL;
18047 }
18048
18049
18050 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18051 PyObject *resultobj = 0;
18052 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18053 int result;
18054 void *argp1 = 0 ;
18055 int res1 = 0 ;
18056 PyObject *swig_obj[1] ;
18057
18058 if (!args) SWIG_fail;
18059 swig_obj[0] = args;
18060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18061 if (!SWIG_IsOK(res1)) {
18062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18063 }
18064 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18065 {
18066 PyThreadState* __tstate = wxPyBeginAllowThreads();
18067 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18068 wxPyEndAllowThreads(__tstate);
18069 if (PyErr_Occurred()) SWIG_fail;
18070 }
18071 resultobj = SWIG_From_int(static_cast< int >(result));
18072 return resultobj;
18073 fail:
18074 return NULL;
18075 }
18076
18077
18078 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18079 PyObject *obj;
18080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18081 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18082 return SWIG_Py_Void();
18083 }
18084
18085 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18086 return SWIG_Python_InitShadowInstance(args);
18087 }
18088
18089 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18090 PyObject *resultobj = 0;
18091 wxFileTypeInfo *arg1 = 0 ;
18092 wxFileType *result = 0 ;
18093 void *argp1 = 0 ;
18094 int res1 = 0 ;
18095 PyObject * obj0 = 0 ;
18096 char * kwnames[] = {
18097 (char *) "ftInfo", NULL
18098 };
18099
18100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18101 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18102 if (!SWIG_IsOK(res1)) {
18103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18104 }
18105 if (!argp1) {
18106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18107 }
18108 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18109 {
18110 PyThreadState* __tstate = wxPyBeginAllowThreads();
18111 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18112 wxPyEndAllowThreads(__tstate);
18113 if (PyErr_Occurred()) SWIG_fail;
18114 }
18115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18116 return resultobj;
18117 fail:
18118 return NULL;
18119 }
18120
18121
18122 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18123 PyObject *resultobj = 0;
18124 wxFileType *arg1 = (wxFileType *) 0 ;
18125 void *argp1 = 0 ;
18126 int res1 = 0 ;
18127 PyObject *swig_obj[1] ;
18128
18129 if (!args) SWIG_fail;
18130 swig_obj[0] = args;
18131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18132 if (!SWIG_IsOK(res1)) {
18133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18134 }
18135 arg1 = reinterpret_cast< wxFileType * >(argp1);
18136 {
18137 PyThreadState* __tstate = wxPyBeginAllowThreads();
18138 delete arg1;
18139
18140 wxPyEndAllowThreads(__tstate);
18141 if (PyErr_Occurred()) SWIG_fail;
18142 }
18143 resultobj = SWIG_Py_Void();
18144 return resultobj;
18145 fail:
18146 return NULL;
18147 }
18148
18149
18150 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18151 PyObject *resultobj = 0;
18152 wxFileType *arg1 = (wxFileType *) 0 ;
18153 PyObject *result = 0 ;
18154 void *argp1 = 0 ;
18155 int res1 = 0 ;
18156 PyObject *swig_obj[1] ;
18157
18158 if (!args) SWIG_fail;
18159 swig_obj[0] = args;
18160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18161 if (!SWIG_IsOK(res1)) {
18162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18163 }
18164 arg1 = reinterpret_cast< wxFileType * >(argp1);
18165 {
18166 PyThreadState* __tstate = wxPyBeginAllowThreads();
18167 result = (PyObject *)wxFileType_GetMimeType(arg1);
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 resultobj = result;
18172 return resultobj;
18173 fail:
18174 return NULL;
18175 }
18176
18177
18178 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18179 PyObject *resultobj = 0;
18180 wxFileType *arg1 = (wxFileType *) 0 ;
18181 PyObject *result = 0 ;
18182 void *argp1 = 0 ;
18183 int res1 = 0 ;
18184 PyObject *swig_obj[1] ;
18185
18186 if (!args) SWIG_fail;
18187 swig_obj[0] = args;
18188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18189 if (!SWIG_IsOK(res1)) {
18190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18191 }
18192 arg1 = reinterpret_cast< wxFileType * >(argp1);
18193 {
18194 PyThreadState* __tstate = wxPyBeginAllowThreads();
18195 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18196 wxPyEndAllowThreads(__tstate);
18197 if (PyErr_Occurred()) SWIG_fail;
18198 }
18199 resultobj = result;
18200 return resultobj;
18201 fail:
18202 return NULL;
18203 }
18204
18205
18206 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18207 PyObject *resultobj = 0;
18208 wxFileType *arg1 = (wxFileType *) 0 ;
18209 PyObject *result = 0 ;
18210 void *argp1 = 0 ;
18211 int res1 = 0 ;
18212 PyObject *swig_obj[1] ;
18213
18214 if (!args) SWIG_fail;
18215 swig_obj[0] = args;
18216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18217 if (!SWIG_IsOK(res1)) {
18218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18219 }
18220 arg1 = reinterpret_cast< wxFileType * >(argp1);
18221 {
18222 PyThreadState* __tstate = wxPyBeginAllowThreads();
18223 result = (PyObject *)wxFileType_GetExtensions(arg1);
18224 wxPyEndAllowThreads(__tstate);
18225 if (PyErr_Occurred()) SWIG_fail;
18226 }
18227 resultobj = result;
18228 return resultobj;
18229 fail:
18230 return NULL;
18231 }
18232
18233
18234 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18235 PyObject *resultobj = 0;
18236 wxFileType *arg1 = (wxFileType *) 0 ;
18237 wxIcon *result = 0 ;
18238 void *argp1 = 0 ;
18239 int res1 = 0 ;
18240 PyObject *swig_obj[1] ;
18241
18242 if (!args) SWIG_fail;
18243 swig_obj[0] = args;
18244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18247 }
18248 arg1 = reinterpret_cast< wxFileType * >(argp1);
18249 {
18250 PyThreadState* __tstate = wxPyBeginAllowThreads();
18251 result = (wxIcon *)wxFileType_GetIcon(arg1);
18252 wxPyEndAllowThreads(__tstate);
18253 if (PyErr_Occurred()) SWIG_fail;
18254 }
18255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18256 return resultobj;
18257 fail:
18258 return NULL;
18259 }
18260
18261
18262 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18263 PyObject *resultobj = 0;
18264 wxFileType *arg1 = (wxFileType *) 0 ;
18265 PyObject *result = 0 ;
18266 void *argp1 = 0 ;
18267 int res1 = 0 ;
18268 PyObject *swig_obj[1] ;
18269
18270 if (!args) SWIG_fail;
18271 swig_obj[0] = args;
18272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18273 if (!SWIG_IsOK(res1)) {
18274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18275 }
18276 arg1 = reinterpret_cast< wxFileType * >(argp1);
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18280 wxPyEndAllowThreads(__tstate);
18281 if (PyErr_Occurred()) SWIG_fail;
18282 }
18283 resultobj = result;
18284 return resultobj;
18285 fail:
18286 return NULL;
18287 }
18288
18289
18290 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18291 PyObject *resultobj = 0;
18292 wxFileType *arg1 = (wxFileType *) 0 ;
18293 PyObject *result = 0 ;
18294 void *argp1 = 0 ;
18295 int res1 = 0 ;
18296 PyObject *swig_obj[1] ;
18297
18298 if (!args) SWIG_fail;
18299 swig_obj[0] = args;
18300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18301 if (!SWIG_IsOK(res1)) {
18302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18303 }
18304 arg1 = reinterpret_cast< wxFileType * >(argp1);
18305 {
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 result = (PyObject *)wxFileType_GetDescription(arg1);
18308 wxPyEndAllowThreads(__tstate);
18309 if (PyErr_Occurred()) SWIG_fail;
18310 }
18311 resultobj = result;
18312 return resultobj;
18313 fail:
18314 return NULL;
18315 }
18316
18317
18318 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18319 PyObject *resultobj = 0;
18320 wxFileType *arg1 = (wxFileType *) 0 ;
18321 wxString *arg2 = 0 ;
18322 wxString const &arg3_defvalue = wxPyEmptyString ;
18323 wxString *arg3 = (wxString *) &arg3_defvalue ;
18324 PyObject *result = 0 ;
18325 void *argp1 = 0 ;
18326 int res1 = 0 ;
18327 bool temp2 = false ;
18328 bool temp3 = false ;
18329 PyObject * obj0 = 0 ;
18330 PyObject * obj1 = 0 ;
18331 PyObject * obj2 = 0 ;
18332 char * kwnames[] = {
18333 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18334 };
18335
18336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18338 if (!SWIG_IsOK(res1)) {
18339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18340 }
18341 arg1 = reinterpret_cast< wxFileType * >(argp1);
18342 {
18343 arg2 = wxString_in_helper(obj1);
18344 if (arg2 == NULL) SWIG_fail;
18345 temp2 = true;
18346 }
18347 if (obj2) {
18348 {
18349 arg3 = wxString_in_helper(obj2);
18350 if (arg3 == NULL) SWIG_fail;
18351 temp3 = true;
18352 }
18353 }
18354 {
18355 PyThreadState* __tstate = wxPyBeginAllowThreads();
18356 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18357 wxPyEndAllowThreads(__tstate);
18358 if (PyErr_Occurred()) SWIG_fail;
18359 }
18360 resultobj = result;
18361 {
18362 if (temp2)
18363 delete arg2;
18364 }
18365 {
18366 if (temp3)
18367 delete arg3;
18368 }
18369 return resultobj;
18370 fail:
18371 {
18372 if (temp2)
18373 delete arg2;
18374 }
18375 {
18376 if (temp3)
18377 delete arg3;
18378 }
18379 return NULL;
18380 }
18381
18382
18383 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18384 PyObject *resultobj = 0;
18385 wxFileType *arg1 = (wxFileType *) 0 ;
18386 wxString *arg2 = 0 ;
18387 wxString const &arg3_defvalue = wxPyEmptyString ;
18388 wxString *arg3 = (wxString *) &arg3_defvalue ;
18389 PyObject *result = 0 ;
18390 void *argp1 = 0 ;
18391 int res1 = 0 ;
18392 bool temp2 = false ;
18393 bool temp3 = false ;
18394 PyObject * obj0 = 0 ;
18395 PyObject * obj1 = 0 ;
18396 PyObject * obj2 = 0 ;
18397 char * kwnames[] = {
18398 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18399 };
18400
18401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18403 if (!SWIG_IsOK(res1)) {
18404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18405 }
18406 arg1 = reinterpret_cast< wxFileType * >(argp1);
18407 {
18408 arg2 = wxString_in_helper(obj1);
18409 if (arg2 == NULL) SWIG_fail;
18410 temp2 = true;
18411 }
18412 if (obj2) {
18413 {
18414 arg3 = wxString_in_helper(obj2);
18415 if (arg3 == NULL) SWIG_fail;
18416 temp3 = true;
18417 }
18418 }
18419 {
18420 PyThreadState* __tstate = wxPyBeginAllowThreads();
18421 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18422 wxPyEndAllowThreads(__tstate);
18423 if (PyErr_Occurred()) SWIG_fail;
18424 }
18425 resultobj = result;
18426 {
18427 if (temp2)
18428 delete arg2;
18429 }
18430 {
18431 if (temp3)
18432 delete arg3;
18433 }
18434 return resultobj;
18435 fail:
18436 {
18437 if (temp2)
18438 delete arg2;
18439 }
18440 {
18441 if (temp3)
18442 delete arg3;
18443 }
18444 return NULL;
18445 }
18446
18447
18448 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18449 PyObject *resultobj = 0;
18450 wxFileType *arg1 = (wxFileType *) 0 ;
18451 wxString *arg2 = 0 ;
18452 wxString const &arg3_defvalue = wxPyEmptyString ;
18453 wxString *arg3 = (wxString *) &arg3_defvalue ;
18454 PyObject *result = 0 ;
18455 void *argp1 = 0 ;
18456 int res1 = 0 ;
18457 bool temp2 = false ;
18458 bool temp3 = false ;
18459 PyObject * obj0 = 0 ;
18460 PyObject * obj1 = 0 ;
18461 PyObject * obj2 = 0 ;
18462 char * kwnames[] = {
18463 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18464 };
18465
18466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18468 if (!SWIG_IsOK(res1)) {
18469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18470 }
18471 arg1 = reinterpret_cast< wxFileType * >(argp1);
18472 {
18473 arg2 = wxString_in_helper(obj1);
18474 if (arg2 == NULL) SWIG_fail;
18475 temp2 = true;
18476 }
18477 if (obj2) {
18478 {
18479 arg3 = wxString_in_helper(obj2);
18480 if (arg3 == NULL) SWIG_fail;
18481 temp3 = true;
18482 }
18483 }
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 resultobj = result;
18491 {
18492 if (temp2)
18493 delete arg2;
18494 }
18495 {
18496 if (temp3)
18497 delete arg3;
18498 }
18499 return resultobj;
18500 fail:
18501 {
18502 if (temp2)
18503 delete arg2;
18504 }
18505 {
18506 if (temp3)
18507 delete arg3;
18508 }
18509 return NULL;
18510 }
18511
18512
18513 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18514 PyObject *resultobj = 0;
18515 wxFileType *arg1 = (wxFileType *) 0 ;
18516 wxString *arg2 = 0 ;
18517 wxString *arg3 = 0 ;
18518 bool arg4 = (bool) true ;
18519 bool result;
18520 void *argp1 = 0 ;
18521 int res1 = 0 ;
18522 bool temp2 = false ;
18523 bool temp3 = false ;
18524 bool val4 ;
18525 int ecode4 = 0 ;
18526 PyObject * obj0 = 0 ;
18527 PyObject * obj1 = 0 ;
18528 PyObject * obj2 = 0 ;
18529 PyObject * obj3 = 0 ;
18530 char * kwnames[] = {
18531 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18532 };
18533
18534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18536 if (!SWIG_IsOK(res1)) {
18537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18538 }
18539 arg1 = reinterpret_cast< wxFileType * >(argp1);
18540 {
18541 arg2 = wxString_in_helper(obj1);
18542 if (arg2 == NULL) SWIG_fail;
18543 temp2 = true;
18544 }
18545 {
18546 arg3 = wxString_in_helper(obj2);
18547 if (arg3 == NULL) SWIG_fail;
18548 temp3 = true;
18549 }
18550 if (obj3) {
18551 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18552 if (!SWIG_IsOK(ecode4)) {
18553 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18554 }
18555 arg4 = static_cast< bool >(val4);
18556 }
18557 {
18558 PyThreadState* __tstate = wxPyBeginAllowThreads();
18559 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18560 wxPyEndAllowThreads(__tstate);
18561 if (PyErr_Occurred()) SWIG_fail;
18562 }
18563 {
18564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18565 }
18566 {
18567 if (temp2)
18568 delete arg2;
18569 }
18570 {
18571 if (temp3)
18572 delete arg3;
18573 }
18574 return resultobj;
18575 fail:
18576 {
18577 if (temp2)
18578 delete arg2;
18579 }
18580 {
18581 if (temp3)
18582 delete arg3;
18583 }
18584 return NULL;
18585 }
18586
18587
18588 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18589 PyObject *resultobj = 0;
18590 wxFileType *arg1 = (wxFileType *) 0 ;
18591 wxString const &arg2_defvalue = wxPyEmptyString ;
18592 wxString *arg2 = (wxString *) &arg2_defvalue ;
18593 int arg3 = (int) 0 ;
18594 bool result;
18595 void *argp1 = 0 ;
18596 int res1 = 0 ;
18597 bool temp2 = false ;
18598 int val3 ;
18599 int ecode3 = 0 ;
18600 PyObject * obj0 = 0 ;
18601 PyObject * obj1 = 0 ;
18602 PyObject * obj2 = 0 ;
18603 char * kwnames[] = {
18604 (char *) "self",(char *) "cmd",(char *) "index", NULL
18605 };
18606
18607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18609 if (!SWIG_IsOK(res1)) {
18610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18611 }
18612 arg1 = reinterpret_cast< wxFileType * >(argp1);
18613 if (obj1) {
18614 {
18615 arg2 = wxString_in_helper(obj1);
18616 if (arg2 == NULL) SWIG_fail;
18617 temp2 = true;
18618 }
18619 }
18620 if (obj2) {
18621 ecode3 = SWIG_AsVal_int(obj2, &val3);
18622 if (!SWIG_IsOK(ecode3)) {
18623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18624 }
18625 arg3 = static_cast< int >(val3);
18626 }
18627 {
18628 PyThreadState* __tstate = wxPyBeginAllowThreads();
18629 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18630 wxPyEndAllowThreads(__tstate);
18631 if (PyErr_Occurred()) SWIG_fail;
18632 }
18633 {
18634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18635 }
18636 {
18637 if (temp2)
18638 delete arg2;
18639 }
18640 return resultobj;
18641 fail:
18642 {
18643 if (temp2)
18644 delete arg2;
18645 }
18646 return NULL;
18647 }
18648
18649
18650 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18651 PyObject *resultobj = 0;
18652 wxFileType *arg1 = (wxFileType *) 0 ;
18653 bool result;
18654 void *argp1 = 0 ;
18655 int res1 = 0 ;
18656 PyObject *swig_obj[1] ;
18657
18658 if (!args) SWIG_fail;
18659 swig_obj[0] = args;
18660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18661 if (!SWIG_IsOK(res1)) {
18662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18663 }
18664 arg1 = reinterpret_cast< wxFileType * >(argp1);
18665 {
18666 PyThreadState* __tstate = wxPyBeginAllowThreads();
18667 result = (bool)(arg1)->Unassociate();
18668 wxPyEndAllowThreads(__tstate);
18669 if (PyErr_Occurred()) SWIG_fail;
18670 }
18671 {
18672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18673 }
18674 return resultobj;
18675 fail:
18676 return NULL;
18677 }
18678
18679
18680 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj = 0;
18682 wxString *arg1 = 0 ;
18683 wxString *arg2 = 0 ;
18684 wxString const &arg3_defvalue = wxPyEmptyString ;
18685 wxString *arg3 = (wxString *) &arg3_defvalue ;
18686 wxString result;
18687 bool temp1 = false ;
18688 bool temp2 = false ;
18689 bool temp3 = false ;
18690 PyObject * obj0 = 0 ;
18691 PyObject * obj1 = 0 ;
18692 PyObject * obj2 = 0 ;
18693 char * kwnames[] = {
18694 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18695 };
18696
18697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) 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 if (obj2) {
18709 {
18710 arg3 = wxString_in_helper(obj2);
18711 if (arg3 == NULL) SWIG_fail;
18712 temp3 = true;
18713 }
18714 }
18715 {
18716 PyThreadState* __tstate = wxPyBeginAllowThreads();
18717 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18718 wxPyEndAllowThreads(__tstate);
18719 if (PyErr_Occurred()) SWIG_fail;
18720 }
18721 {
18722 #if wxUSE_UNICODE
18723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18724 #else
18725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18726 #endif
18727 }
18728 {
18729 if (temp1)
18730 delete arg1;
18731 }
18732 {
18733 if (temp2)
18734 delete arg2;
18735 }
18736 {
18737 if (temp3)
18738 delete arg3;
18739 }
18740 return resultobj;
18741 fail:
18742 {
18743 if (temp1)
18744 delete arg1;
18745 }
18746 {
18747 if (temp2)
18748 delete arg2;
18749 }
18750 {
18751 if (temp3)
18752 delete arg3;
18753 }
18754 return NULL;
18755 }
18756
18757
18758 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18759 PyObject *obj;
18760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18761 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18762 return SWIG_Py_Void();
18763 }
18764
18765 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18766 return SWIG_Python_InitShadowInstance(args);
18767 }
18768
18769 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18770 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18771 return 1;
18772 }
18773
18774
18775 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18776 PyObject *pyobj = 0;
18777
18778 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18779 return pyobj;
18780 }
18781
18782
18783 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18784 PyObject *resultobj = 0;
18785 wxString *arg1 = 0 ;
18786 wxString *arg2 = 0 ;
18787 bool result;
18788 bool temp1 = false ;
18789 bool temp2 = false ;
18790 PyObject * obj0 = 0 ;
18791 PyObject * obj1 = 0 ;
18792 char * kwnames[] = {
18793 (char *) "mimeType",(char *) "wildcard", NULL
18794 };
18795
18796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18797 {
18798 arg1 = wxString_in_helper(obj0);
18799 if (arg1 == NULL) SWIG_fail;
18800 temp1 = true;
18801 }
18802 {
18803 arg2 = wxString_in_helper(obj1);
18804 if (arg2 == NULL) SWIG_fail;
18805 temp2 = true;
18806 }
18807 {
18808 PyThreadState* __tstate = wxPyBeginAllowThreads();
18809 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18810 wxPyEndAllowThreads(__tstate);
18811 if (PyErr_Occurred()) SWIG_fail;
18812 }
18813 {
18814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18815 }
18816 {
18817 if (temp1)
18818 delete arg1;
18819 }
18820 {
18821 if (temp2)
18822 delete arg2;
18823 }
18824 return resultobj;
18825 fail:
18826 {
18827 if (temp1)
18828 delete arg1;
18829 }
18830 {
18831 if (temp2)
18832 delete arg2;
18833 }
18834 return NULL;
18835 }
18836
18837
18838 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18839 PyObject *resultobj = 0;
18840 wxMimeTypesManager *result = 0 ;
18841
18842 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18843 {
18844 PyThreadState* __tstate = wxPyBeginAllowThreads();
18845 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18846 wxPyEndAllowThreads(__tstate);
18847 if (PyErr_Occurred()) SWIG_fail;
18848 }
18849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18850 return resultobj;
18851 fail:
18852 return NULL;
18853 }
18854
18855
18856 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18857 PyObject *resultobj = 0;
18858 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18859 int arg2 = (int) wxMAILCAP_ALL ;
18860 wxString const &arg3_defvalue = wxPyEmptyString ;
18861 wxString *arg3 = (wxString *) &arg3_defvalue ;
18862 void *argp1 = 0 ;
18863 int res1 = 0 ;
18864 int val2 ;
18865 int ecode2 = 0 ;
18866 bool temp3 = false ;
18867 PyObject * obj0 = 0 ;
18868 PyObject * obj1 = 0 ;
18869 PyObject * obj2 = 0 ;
18870 char * kwnames[] = {
18871 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18872 };
18873
18874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18876 if (!SWIG_IsOK(res1)) {
18877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18878 }
18879 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18880 if (obj1) {
18881 ecode2 = SWIG_AsVal_int(obj1, &val2);
18882 if (!SWIG_IsOK(ecode2)) {
18883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18884 }
18885 arg2 = static_cast< int >(val2);
18886 }
18887 if (obj2) {
18888 {
18889 arg3 = wxString_in_helper(obj2);
18890 if (arg3 == NULL) SWIG_fail;
18891 temp3 = true;
18892 }
18893 }
18894 {
18895 PyThreadState* __tstate = wxPyBeginAllowThreads();
18896 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18897 wxPyEndAllowThreads(__tstate);
18898 if (PyErr_Occurred()) SWIG_fail;
18899 }
18900 resultobj = SWIG_Py_Void();
18901 {
18902 if (temp3)
18903 delete arg3;
18904 }
18905 return resultobj;
18906 fail:
18907 {
18908 if (temp3)
18909 delete arg3;
18910 }
18911 return NULL;
18912 }
18913
18914
18915 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18916 PyObject *resultobj = 0;
18917 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18918 void *argp1 = 0 ;
18919 int res1 = 0 ;
18920 PyObject *swig_obj[1] ;
18921
18922 if (!args) SWIG_fail;
18923 swig_obj[0] = args;
18924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18925 if (!SWIG_IsOK(res1)) {
18926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18927 }
18928 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18929 {
18930 PyThreadState* __tstate = wxPyBeginAllowThreads();
18931 (arg1)->ClearData();
18932 wxPyEndAllowThreads(__tstate);
18933 if (PyErr_Occurred()) SWIG_fail;
18934 }
18935 resultobj = SWIG_Py_Void();
18936 return resultobj;
18937 fail:
18938 return NULL;
18939 }
18940
18941
18942 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18943 PyObject *resultobj = 0;
18944 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18945 wxString *arg2 = 0 ;
18946 wxFileType *result = 0 ;
18947 void *argp1 = 0 ;
18948 int res1 = 0 ;
18949 bool temp2 = false ;
18950 PyObject * obj0 = 0 ;
18951 PyObject * obj1 = 0 ;
18952 char * kwnames[] = {
18953 (char *) "self",(char *) "ext", NULL
18954 };
18955
18956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18958 if (!SWIG_IsOK(res1)) {
18959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18960 }
18961 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18962 {
18963 arg2 = wxString_in_helper(obj1);
18964 if (arg2 == NULL) SWIG_fail;
18965 temp2 = true;
18966 }
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18974 {
18975 if (temp2)
18976 delete arg2;
18977 }
18978 return resultobj;
18979 fail:
18980 {
18981 if (temp2)
18982 delete arg2;
18983 }
18984 return NULL;
18985 }
18986
18987
18988 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18989 PyObject *resultobj = 0;
18990 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18991 wxString *arg2 = 0 ;
18992 wxFileType *result = 0 ;
18993 void *argp1 = 0 ;
18994 int res1 = 0 ;
18995 bool temp2 = false ;
18996 PyObject * obj0 = 0 ;
18997 PyObject * obj1 = 0 ;
18998 char * kwnames[] = {
18999 (char *) "self",(char *) "mimeType", NULL
19000 };
19001
19002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
19003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19004 if (!SWIG_IsOK(res1)) {
19005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19006 }
19007 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19008 {
19009 arg2 = wxString_in_helper(obj1);
19010 if (arg2 == NULL) SWIG_fail;
19011 temp2 = true;
19012 }
19013 {
19014 PyThreadState* __tstate = wxPyBeginAllowThreads();
19015 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19016 wxPyEndAllowThreads(__tstate);
19017 if (PyErr_Occurred()) SWIG_fail;
19018 }
19019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19020 {
19021 if (temp2)
19022 delete arg2;
19023 }
19024 return resultobj;
19025 fail:
19026 {
19027 if (temp2)
19028 delete arg2;
19029 }
19030 return NULL;
19031 }
19032
19033
19034 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj = 0;
19036 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19037 wxString *arg2 = 0 ;
19038 bool arg3 = (bool) false ;
19039 bool result;
19040 void *argp1 = 0 ;
19041 int res1 = 0 ;
19042 bool temp2 = false ;
19043 bool val3 ;
19044 int ecode3 = 0 ;
19045 PyObject * obj0 = 0 ;
19046 PyObject * obj1 = 0 ;
19047 PyObject * obj2 = 0 ;
19048 char * kwnames[] = {
19049 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19050 };
19051
19052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19054 if (!SWIG_IsOK(res1)) {
19055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19056 }
19057 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19058 {
19059 arg2 = wxString_in_helper(obj1);
19060 if (arg2 == NULL) SWIG_fail;
19061 temp2 = true;
19062 }
19063 if (obj2) {
19064 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19065 if (!SWIG_IsOK(ecode3)) {
19066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19067 }
19068 arg3 = static_cast< bool >(val3);
19069 }
19070 {
19071 PyThreadState* __tstate = wxPyBeginAllowThreads();
19072 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19073 wxPyEndAllowThreads(__tstate);
19074 if (PyErr_Occurred()) SWIG_fail;
19075 }
19076 {
19077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19078 }
19079 {
19080 if (temp2)
19081 delete arg2;
19082 }
19083 return resultobj;
19084 fail:
19085 {
19086 if (temp2)
19087 delete arg2;
19088 }
19089 return NULL;
19090 }
19091
19092
19093 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19094 PyObject *resultobj = 0;
19095 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19096 wxString *arg2 = 0 ;
19097 bool result;
19098 void *argp1 = 0 ;
19099 int res1 = 0 ;
19100 bool temp2 = false ;
19101 PyObject * obj0 = 0 ;
19102 PyObject * obj1 = 0 ;
19103 char * kwnames[] = {
19104 (char *) "self",(char *) "filename", NULL
19105 };
19106
19107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19109 if (!SWIG_IsOK(res1)) {
19110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19111 }
19112 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19113 {
19114 arg2 = wxString_in_helper(obj1);
19115 if (arg2 == NULL) SWIG_fail;
19116 temp2 = true;
19117 }
19118 {
19119 PyThreadState* __tstate = wxPyBeginAllowThreads();
19120 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19121 wxPyEndAllowThreads(__tstate);
19122 if (PyErr_Occurred()) SWIG_fail;
19123 }
19124 {
19125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19126 }
19127 {
19128 if (temp2)
19129 delete arg2;
19130 }
19131 return resultobj;
19132 fail:
19133 {
19134 if (temp2)
19135 delete arg2;
19136 }
19137 return NULL;
19138 }
19139
19140
19141 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19142 PyObject *resultobj = 0;
19143 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19144 PyObject *result = 0 ;
19145 void *argp1 = 0 ;
19146 int res1 = 0 ;
19147 PyObject *swig_obj[1] ;
19148
19149 if (!args) SWIG_fail;
19150 swig_obj[0] = args;
19151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19152 if (!SWIG_IsOK(res1)) {
19153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19154 }
19155 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19156 {
19157 PyThreadState* __tstate = wxPyBeginAllowThreads();
19158 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19159 wxPyEndAllowThreads(__tstate);
19160 if (PyErr_Occurred()) SWIG_fail;
19161 }
19162 resultobj = result;
19163 return resultobj;
19164 fail:
19165 return NULL;
19166 }
19167
19168
19169 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19170 PyObject *resultobj = 0;
19171 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19172 wxFileTypeInfo *arg2 = 0 ;
19173 void *argp1 = 0 ;
19174 int res1 = 0 ;
19175 void *argp2 = 0 ;
19176 int res2 = 0 ;
19177 PyObject * obj0 = 0 ;
19178 PyObject * obj1 = 0 ;
19179 char * kwnames[] = {
19180 (char *) "self",(char *) "ft", NULL
19181 };
19182
19183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19185 if (!SWIG_IsOK(res1)) {
19186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19187 }
19188 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19189 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19190 if (!SWIG_IsOK(res2)) {
19191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19192 }
19193 if (!argp2) {
19194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19195 }
19196 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19197 {
19198 PyThreadState* __tstate = wxPyBeginAllowThreads();
19199 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19200 wxPyEndAllowThreads(__tstate);
19201 if (PyErr_Occurred()) SWIG_fail;
19202 }
19203 resultobj = SWIG_Py_Void();
19204 return resultobj;
19205 fail:
19206 return NULL;
19207 }
19208
19209
19210 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19211 PyObject *resultobj = 0;
19212 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19213 wxFileTypeInfo *arg2 = 0 ;
19214 wxFileType *result = 0 ;
19215 void *argp1 = 0 ;
19216 int res1 = 0 ;
19217 void *argp2 = 0 ;
19218 int res2 = 0 ;
19219 PyObject * obj0 = 0 ;
19220 PyObject * obj1 = 0 ;
19221 char * kwnames[] = {
19222 (char *) "self",(char *) "ftInfo", NULL
19223 };
19224
19225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19227 if (!SWIG_IsOK(res1)) {
19228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19229 }
19230 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19231 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19232 if (!SWIG_IsOK(res2)) {
19233 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19234 }
19235 if (!argp2) {
19236 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19237 }
19238 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19239 {
19240 PyThreadState* __tstate = wxPyBeginAllowThreads();
19241 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19242 wxPyEndAllowThreads(__tstate);
19243 if (PyErr_Occurred()) SWIG_fail;
19244 }
19245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19246 return resultobj;
19247 fail:
19248 return NULL;
19249 }
19250
19251
19252 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19253 PyObject *resultobj = 0;
19254 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19255 wxFileType *arg2 = (wxFileType *) 0 ;
19256 bool result;
19257 void *argp1 = 0 ;
19258 int res1 = 0 ;
19259 void *argp2 = 0 ;
19260 int res2 = 0 ;
19261 PyObject * obj0 = 0 ;
19262 PyObject * obj1 = 0 ;
19263 char * kwnames[] = {
19264 (char *) "self",(char *) "ft", NULL
19265 };
19266
19267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19269 if (!SWIG_IsOK(res1)) {
19270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19271 }
19272 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19274 if (!SWIG_IsOK(res2)) {
19275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19276 }
19277 arg2 = reinterpret_cast< wxFileType * >(argp2);
19278 {
19279 PyThreadState* __tstate = wxPyBeginAllowThreads();
19280 result = (bool)(arg1)->Unassociate(arg2);
19281 wxPyEndAllowThreads(__tstate);
19282 if (PyErr_Occurred()) SWIG_fail;
19283 }
19284 {
19285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19286 }
19287 return resultobj;
19288 fail:
19289 return NULL;
19290 }
19291
19292
19293 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19294 PyObject *resultobj = 0;
19295 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19296 void *argp1 = 0 ;
19297 int res1 = 0 ;
19298 PyObject *swig_obj[1] ;
19299
19300 if (!args) SWIG_fail;
19301 swig_obj[0] = args;
19302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19303 if (!SWIG_IsOK(res1)) {
19304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19305 }
19306 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19307 {
19308 PyThreadState* __tstate = wxPyBeginAllowThreads();
19309 delete arg1;
19310
19311 wxPyEndAllowThreads(__tstate);
19312 if (PyErr_Occurred()) SWIG_fail;
19313 }
19314 resultobj = SWIG_Py_Void();
19315 return resultobj;
19316 fail:
19317 return NULL;
19318 }
19319
19320
19321 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19322 PyObject *obj;
19323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19324 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19325 return SWIG_Py_Void();
19326 }
19327
19328 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19329 return SWIG_Python_InitShadowInstance(args);
19330 }
19331
19332 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19333 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19334 return 1;
19335 }
19336
19337
19338 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19339 PyObject *pyobj = 0;
19340
19341 {
19342 #if wxUSE_UNICODE
19343 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19344 #else
19345 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19346 #endif
19347 }
19348 return pyobj;
19349 }
19350
19351
19352 SWIGINTERN int ART_MENU_set(PyObject *) {
19353 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19354 return 1;
19355 }
19356
19357
19358 SWIGINTERN PyObject *ART_MENU_get(void) {
19359 PyObject *pyobj = 0;
19360
19361 {
19362 #if wxUSE_UNICODE
19363 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19364 #else
19365 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19366 #endif
19367 }
19368 return pyobj;
19369 }
19370
19371
19372 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19373 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19374 return 1;
19375 }
19376
19377
19378 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19379 PyObject *pyobj = 0;
19380
19381 {
19382 #if wxUSE_UNICODE
19383 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19384 #else
19385 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19386 #endif
19387 }
19388 return pyobj;
19389 }
19390
19391
19392 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19393 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19394 return 1;
19395 }
19396
19397
19398 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19399 PyObject *pyobj = 0;
19400
19401 {
19402 #if wxUSE_UNICODE
19403 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19404 #else
19405 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19406 #endif
19407 }
19408 return pyobj;
19409 }
19410
19411
19412 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19413 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19414 return 1;
19415 }
19416
19417
19418 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19419 PyObject *pyobj = 0;
19420
19421 {
19422 #if wxUSE_UNICODE
19423 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19424 #else
19425 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19426 #endif
19427 }
19428 return pyobj;
19429 }
19430
19431
19432 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19433 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19434 return 1;
19435 }
19436
19437
19438 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19439 PyObject *pyobj = 0;
19440
19441 {
19442 #if wxUSE_UNICODE
19443 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19444 #else
19445 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19446 #endif
19447 }
19448 return pyobj;
19449 }
19450
19451
19452 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19453 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19454 return 1;
19455 }
19456
19457
19458 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19459 PyObject *pyobj = 0;
19460
19461 {
19462 #if wxUSE_UNICODE
19463 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19464 #else
19465 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19466 #endif
19467 }
19468 return pyobj;
19469 }
19470
19471
19472 SWIGINTERN int ART_LIST_set(PyObject *) {
19473 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST is read-only.");
19474 return 1;
19475 }
19476
19477
19478 SWIGINTERN PyObject *ART_LIST_get(void) {
19479 PyObject *pyobj = 0;
19480
19481 {
19482 #if wxUSE_UNICODE
19483 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST)->c_str(), (&wxPyART_LIST)->Len());
19484 #else
19485 pyobj = PyString_FromStringAndSize((&wxPyART_LIST)->c_str(), (&wxPyART_LIST)->Len());
19486 #endif
19487 }
19488 return pyobj;
19489 }
19490
19491
19492 SWIGINTERN int ART_OTHER_set(PyObject *) {
19493 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19494 return 1;
19495 }
19496
19497
19498 SWIGINTERN PyObject *ART_OTHER_get(void) {
19499 PyObject *pyobj = 0;
19500
19501 {
19502 #if wxUSE_UNICODE
19503 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19504 #else
19505 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19506 #endif
19507 }
19508 return pyobj;
19509 }
19510
19511
19512 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19513 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19514 return 1;
19515 }
19516
19517
19518 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19519 PyObject *pyobj = 0;
19520
19521 {
19522 #if wxUSE_UNICODE
19523 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19524 #else
19525 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19526 #endif
19527 }
19528 return pyobj;
19529 }
19530
19531
19532 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19533 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19534 return 1;
19535 }
19536
19537
19538 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19539 PyObject *pyobj = 0;
19540
19541 {
19542 #if wxUSE_UNICODE
19543 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19544 #else
19545 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19546 #endif
19547 }
19548 return pyobj;
19549 }
19550
19551
19552 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19553 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19554 return 1;
19555 }
19556
19557
19558 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19559 PyObject *pyobj = 0;
19560
19561 {
19562 #if wxUSE_UNICODE
19563 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19564 #else
19565 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19566 #endif
19567 }
19568 return pyobj;
19569 }
19570
19571
19572 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19573 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19574 return 1;
19575 }
19576
19577
19578 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19579 PyObject *pyobj = 0;
19580
19581 {
19582 #if wxUSE_UNICODE
19583 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19584 #else
19585 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19586 #endif
19587 }
19588 return pyobj;
19589 }
19590
19591
19592 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19593 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19594 return 1;
19595 }
19596
19597
19598 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19599 PyObject *pyobj = 0;
19600
19601 {
19602 #if wxUSE_UNICODE
19603 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19604 #else
19605 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19606 #endif
19607 }
19608 return pyobj;
19609 }
19610
19611
19612 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19613 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19614 return 1;
19615 }
19616
19617
19618 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19619 PyObject *pyobj = 0;
19620
19621 {
19622 #if wxUSE_UNICODE
19623 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19624 #else
19625 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19626 #endif
19627 }
19628 return pyobj;
19629 }
19630
19631
19632 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19633 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19634 return 1;
19635 }
19636
19637
19638 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19639 PyObject *pyobj = 0;
19640
19641 {
19642 #if wxUSE_UNICODE
19643 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19644 #else
19645 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19646 #endif
19647 }
19648 return pyobj;
19649 }
19650
19651
19652 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19653 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19654 return 1;
19655 }
19656
19657
19658 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19659 PyObject *pyobj = 0;
19660
19661 {
19662 #if wxUSE_UNICODE
19663 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19664 #else
19665 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19666 #endif
19667 }
19668 return pyobj;
19669 }
19670
19671
19672 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19673 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19674 return 1;
19675 }
19676
19677
19678 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19679 PyObject *pyobj = 0;
19680
19681 {
19682 #if wxUSE_UNICODE
19683 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19684 #else
19685 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19686 #endif
19687 }
19688 return pyobj;
19689 }
19690
19691
19692 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19693 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19694 return 1;
19695 }
19696
19697
19698 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19699 PyObject *pyobj = 0;
19700
19701 {
19702 #if wxUSE_UNICODE
19703 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19704 #else
19705 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19706 #endif
19707 }
19708 return pyobj;
19709 }
19710
19711
19712 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19713 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19714 return 1;
19715 }
19716
19717
19718 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19719 PyObject *pyobj = 0;
19720
19721 {
19722 #if wxUSE_UNICODE
19723 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19724 #else
19725 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19726 #endif
19727 }
19728 return pyobj;
19729 }
19730
19731
19732 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19733 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19734 return 1;
19735 }
19736
19737
19738 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19739 PyObject *pyobj = 0;
19740
19741 {
19742 #if wxUSE_UNICODE
19743 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19744 #else
19745 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19746 #endif
19747 }
19748 return pyobj;
19749 }
19750
19751
19752 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19753 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19754 return 1;
19755 }
19756
19757
19758 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19759 PyObject *pyobj = 0;
19760
19761 {
19762 #if wxUSE_UNICODE
19763 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19764 #else
19765 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19766 #endif
19767 }
19768 return pyobj;
19769 }
19770
19771
19772 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19773 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19774 return 1;
19775 }
19776
19777
19778 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19779 PyObject *pyobj = 0;
19780
19781 {
19782 #if wxUSE_UNICODE
19783 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19784 #else
19785 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19786 #endif
19787 }
19788 return pyobj;
19789 }
19790
19791
19792 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19793 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19794 return 1;
19795 }
19796
19797
19798 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19799 PyObject *pyobj = 0;
19800
19801 {
19802 #if wxUSE_UNICODE
19803 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19804 #else
19805 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19806 #endif
19807 }
19808 return pyobj;
19809 }
19810
19811
19812 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19813 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19814 return 1;
19815 }
19816
19817
19818 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19819 PyObject *pyobj = 0;
19820
19821 {
19822 #if wxUSE_UNICODE
19823 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19824 #else
19825 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19826 #endif
19827 }
19828 return pyobj;
19829 }
19830
19831
19832 SWIGINTERN int ART_PRINT_set(PyObject *) {
19833 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19834 return 1;
19835 }
19836
19837
19838 SWIGINTERN PyObject *ART_PRINT_get(void) {
19839 PyObject *pyobj = 0;
19840
19841 {
19842 #if wxUSE_UNICODE
19843 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19844 #else
19845 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19846 #endif
19847 }
19848 return pyobj;
19849 }
19850
19851
19852 SWIGINTERN int ART_HELP_set(PyObject *) {
19853 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19854 return 1;
19855 }
19856
19857
19858 SWIGINTERN PyObject *ART_HELP_get(void) {
19859 PyObject *pyobj = 0;
19860
19861 {
19862 #if wxUSE_UNICODE
19863 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19864 #else
19865 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19866 #endif
19867 }
19868 return pyobj;
19869 }
19870
19871
19872 SWIGINTERN int ART_TIP_set(PyObject *) {
19873 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19874 return 1;
19875 }
19876
19877
19878 SWIGINTERN PyObject *ART_TIP_get(void) {
19879 PyObject *pyobj = 0;
19880
19881 {
19882 #if wxUSE_UNICODE
19883 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19884 #else
19885 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19886 #endif
19887 }
19888 return pyobj;
19889 }
19890
19891
19892 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19893 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19894 return 1;
19895 }
19896
19897
19898 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19899 PyObject *pyobj = 0;
19900
19901 {
19902 #if wxUSE_UNICODE
19903 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19904 #else
19905 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19906 #endif
19907 }
19908 return pyobj;
19909 }
19910
19911
19912 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19913 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19914 return 1;
19915 }
19916
19917
19918 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19919 PyObject *pyobj = 0;
19920
19921 {
19922 #if wxUSE_UNICODE
19923 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19924 #else
19925 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19926 #endif
19927 }
19928 return pyobj;
19929 }
19930
19931
19932 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19933 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19934 return 1;
19935 }
19936
19937
19938 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19939 PyObject *pyobj = 0;
19940
19941 {
19942 #if wxUSE_UNICODE
19943 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19944 #else
19945 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19946 #endif
19947 }
19948 return pyobj;
19949 }
19950
19951
19952 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19953 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19954 return 1;
19955 }
19956
19957
19958 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19959 PyObject *pyobj = 0;
19960
19961 {
19962 #if wxUSE_UNICODE
19963 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19964 #else
19965 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19966 #endif
19967 }
19968 return pyobj;
19969 }
19970
19971
19972 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19973 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19974 return 1;
19975 }
19976
19977
19978 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19979 PyObject *pyobj = 0;
19980
19981 {
19982 #if wxUSE_UNICODE
19983 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19984 #else
19985 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19986 #endif
19987 }
19988 return pyobj;
19989 }
19990
19991
19992 SWIGINTERN int ART_CDROM_set(PyObject *) {
19993 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19994 return 1;
19995 }
19996
19997
19998 SWIGINTERN PyObject *ART_CDROM_get(void) {
19999 PyObject *pyobj = 0;
20000
20001 {
20002 #if wxUSE_UNICODE
20003 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
20004 #else
20005 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
20006 #endif
20007 }
20008 return pyobj;
20009 }
20010
20011
20012 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
20013 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
20014 return 1;
20015 }
20016
20017
20018 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
20019 PyObject *pyobj = 0;
20020
20021 {
20022 #if wxUSE_UNICODE
20023 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20024 #else
20025 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20026 #endif
20027 }
20028 return pyobj;
20029 }
20030
20031
20032 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20033 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20034 return 1;
20035 }
20036
20037
20038 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20039 PyObject *pyobj = 0;
20040
20041 {
20042 #if wxUSE_UNICODE
20043 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20044 #else
20045 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20046 #endif
20047 }
20048 return pyobj;
20049 }
20050
20051
20052 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20053 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20054 return 1;
20055 }
20056
20057
20058 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20059 PyObject *pyobj = 0;
20060
20061 {
20062 #if wxUSE_UNICODE
20063 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20064 #else
20065 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20066 #endif
20067 }
20068 return pyobj;
20069 }
20070
20071
20072 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20073 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20074 return 1;
20075 }
20076
20077
20078 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20079 PyObject *pyobj = 0;
20080
20081 {
20082 #if wxUSE_UNICODE
20083 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20084 #else
20085 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20086 #endif
20087 }
20088 return pyobj;
20089 }
20090
20091
20092 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20093 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20094 return 1;
20095 }
20096
20097
20098 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20099 PyObject *pyobj = 0;
20100
20101 {
20102 #if wxUSE_UNICODE
20103 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20104 #else
20105 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20106 #endif
20107 }
20108 return pyobj;
20109 }
20110
20111
20112 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20113 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20114 return 1;
20115 }
20116
20117
20118 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20119 PyObject *pyobj = 0;
20120
20121 {
20122 #if wxUSE_UNICODE
20123 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20124 #else
20125 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20126 #endif
20127 }
20128 return pyobj;
20129 }
20130
20131
20132 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20133 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20134 return 1;
20135 }
20136
20137
20138 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20139 PyObject *pyobj = 0;
20140
20141 {
20142 #if wxUSE_UNICODE
20143 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20144 #else
20145 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20146 #endif
20147 }
20148 return pyobj;
20149 }
20150
20151
20152 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20153 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20154 return 1;
20155 }
20156
20157
20158 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20159 PyObject *pyobj = 0;
20160
20161 {
20162 #if wxUSE_UNICODE
20163 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20164 #else
20165 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20166 #endif
20167 }
20168 return pyobj;
20169 }
20170
20171
20172 SWIGINTERN int ART_ERROR_set(PyObject *) {
20173 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20174 return 1;
20175 }
20176
20177
20178 SWIGINTERN PyObject *ART_ERROR_get(void) {
20179 PyObject *pyobj = 0;
20180
20181 {
20182 #if wxUSE_UNICODE
20183 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20184 #else
20185 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20186 #endif
20187 }
20188 return pyobj;
20189 }
20190
20191
20192 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20193 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20194 return 1;
20195 }
20196
20197
20198 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20199 PyObject *pyobj = 0;
20200
20201 {
20202 #if wxUSE_UNICODE
20203 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20204 #else
20205 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20206 #endif
20207 }
20208 return pyobj;
20209 }
20210
20211
20212 SWIGINTERN int ART_WARNING_set(PyObject *) {
20213 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20214 return 1;
20215 }
20216
20217
20218 SWIGINTERN PyObject *ART_WARNING_get(void) {
20219 PyObject *pyobj = 0;
20220
20221 {
20222 #if wxUSE_UNICODE
20223 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20224 #else
20225 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20226 #endif
20227 }
20228 return pyobj;
20229 }
20230
20231
20232 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20233 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20234 return 1;
20235 }
20236
20237
20238 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20239 PyObject *pyobj = 0;
20240
20241 {
20242 #if wxUSE_UNICODE
20243 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20244 #else
20245 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20246 #endif
20247 }
20248 return pyobj;
20249 }
20250
20251
20252 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20253 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20254 return 1;
20255 }
20256
20257
20258 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20259 PyObject *pyobj = 0;
20260
20261 {
20262 #if wxUSE_UNICODE
20263 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20264 #else
20265 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20266 #endif
20267 }
20268 return pyobj;
20269 }
20270
20271
20272 SWIGINTERN int ART_COPY_set(PyObject *) {
20273 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20274 return 1;
20275 }
20276
20277
20278 SWIGINTERN PyObject *ART_COPY_get(void) {
20279 PyObject *pyobj = 0;
20280
20281 {
20282 #if wxUSE_UNICODE
20283 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20284 #else
20285 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20286 #endif
20287 }
20288 return pyobj;
20289 }
20290
20291
20292 SWIGINTERN int ART_CUT_set(PyObject *) {
20293 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20294 return 1;
20295 }
20296
20297
20298 SWIGINTERN PyObject *ART_CUT_get(void) {
20299 PyObject *pyobj = 0;
20300
20301 {
20302 #if wxUSE_UNICODE
20303 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20304 #else
20305 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20306 #endif
20307 }
20308 return pyobj;
20309 }
20310
20311
20312 SWIGINTERN int ART_PASTE_set(PyObject *) {
20313 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20314 return 1;
20315 }
20316
20317
20318 SWIGINTERN PyObject *ART_PASTE_get(void) {
20319 PyObject *pyobj = 0;
20320
20321 {
20322 #if wxUSE_UNICODE
20323 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20324 #else
20325 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20326 #endif
20327 }
20328 return pyobj;
20329 }
20330
20331
20332 SWIGINTERN int ART_DELETE_set(PyObject *) {
20333 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20334 return 1;
20335 }
20336
20337
20338 SWIGINTERN PyObject *ART_DELETE_get(void) {
20339 PyObject *pyobj = 0;
20340
20341 {
20342 #if wxUSE_UNICODE
20343 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20344 #else
20345 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20346 #endif
20347 }
20348 return pyobj;
20349 }
20350
20351
20352 SWIGINTERN int ART_NEW_set(PyObject *) {
20353 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20354 return 1;
20355 }
20356
20357
20358 SWIGINTERN PyObject *ART_NEW_get(void) {
20359 PyObject *pyobj = 0;
20360
20361 {
20362 #if wxUSE_UNICODE
20363 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20364 #else
20365 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20366 #endif
20367 }
20368 return pyobj;
20369 }
20370
20371
20372 SWIGINTERN int ART_UNDO_set(PyObject *) {
20373 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20374 return 1;
20375 }
20376
20377
20378 SWIGINTERN PyObject *ART_UNDO_get(void) {
20379 PyObject *pyobj = 0;
20380
20381 {
20382 #if wxUSE_UNICODE
20383 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20384 #else
20385 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20386 #endif
20387 }
20388 return pyobj;
20389 }
20390
20391
20392 SWIGINTERN int ART_REDO_set(PyObject *) {
20393 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20394 return 1;
20395 }
20396
20397
20398 SWIGINTERN PyObject *ART_REDO_get(void) {
20399 PyObject *pyobj = 0;
20400
20401 {
20402 #if wxUSE_UNICODE
20403 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20404 #else
20405 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20406 #endif
20407 }
20408 return pyobj;
20409 }
20410
20411
20412 SWIGINTERN int ART_QUIT_set(PyObject *) {
20413 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20414 return 1;
20415 }
20416
20417
20418 SWIGINTERN PyObject *ART_QUIT_get(void) {
20419 PyObject *pyobj = 0;
20420
20421 {
20422 #if wxUSE_UNICODE
20423 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20424 #else
20425 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20426 #endif
20427 }
20428 return pyobj;
20429 }
20430
20431
20432 SWIGINTERN int ART_FIND_set(PyObject *) {
20433 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20434 return 1;
20435 }
20436
20437
20438 SWIGINTERN PyObject *ART_FIND_get(void) {
20439 PyObject *pyobj = 0;
20440
20441 {
20442 #if wxUSE_UNICODE
20443 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20444 #else
20445 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20446 #endif
20447 }
20448 return pyobj;
20449 }
20450
20451
20452 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20453 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20454 return 1;
20455 }
20456
20457
20458 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20459 PyObject *pyobj = 0;
20460
20461 {
20462 #if wxUSE_UNICODE
20463 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20464 #else
20465 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20466 #endif
20467 }
20468 return pyobj;
20469 }
20470
20471
20472 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20473 PyObject *resultobj = 0;
20474 wxPyArtProvider *result = 0 ;
20475
20476 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20477 {
20478 if (!wxPyCheckForApp()) SWIG_fail;
20479 PyThreadState* __tstate = wxPyBeginAllowThreads();
20480 result = (wxPyArtProvider *)new wxPyArtProvider();
20481 wxPyEndAllowThreads(__tstate);
20482 if (PyErr_Occurred()) SWIG_fail;
20483 }
20484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20485 return resultobj;
20486 fail:
20487 return NULL;
20488 }
20489
20490
20491 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20492 PyObject *resultobj = 0;
20493 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20494 void *argp1 = 0 ;
20495 int res1 = 0 ;
20496 PyObject *swig_obj[1] ;
20497
20498 if (!args) SWIG_fail;
20499 swig_obj[0] = args;
20500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20501 if (!SWIG_IsOK(res1)) {
20502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20503 }
20504 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20505 {
20506 PyThreadState* __tstate = wxPyBeginAllowThreads();
20507 delete arg1;
20508
20509 wxPyEndAllowThreads(__tstate);
20510 if (PyErr_Occurred()) SWIG_fail;
20511 }
20512 resultobj = SWIG_Py_Void();
20513 return resultobj;
20514 fail:
20515 return NULL;
20516 }
20517
20518
20519 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20520 PyObject *resultobj = 0;
20521 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20522 PyObject *arg2 = (PyObject *) 0 ;
20523 PyObject *arg3 = (PyObject *) 0 ;
20524 void *argp1 = 0 ;
20525 int res1 = 0 ;
20526 PyObject * obj0 = 0 ;
20527 PyObject * obj1 = 0 ;
20528 PyObject * obj2 = 0 ;
20529 char * kwnames[] = {
20530 (char *) "self",(char *) "self",(char *) "_class", NULL
20531 };
20532
20533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20535 if (!SWIG_IsOK(res1)) {
20536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20537 }
20538 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20539 arg2 = obj1;
20540 arg3 = obj2;
20541 {
20542 PyThreadState* __tstate = wxPyBeginAllowThreads();
20543 (arg1)->_setCallbackInfo(arg2,arg3);
20544 wxPyEndAllowThreads(__tstate);
20545 if (PyErr_Occurred()) SWIG_fail;
20546 }
20547 resultobj = SWIG_Py_Void();
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20555 PyObject *resultobj = 0;
20556 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20557 int res1 = 0 ;
20558 PyObject * obj0 = 0 ;
20559 char * kwnames[] = {
20560 (char *) "provider", NULL
20561 };
20562
20563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20564 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20565 if (!SWIG_IsOK(res1)) {
20566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20567 }
20568 {
20569 PyThreadState* __tstate = wxPyBeginAllowThreads();
20570 wxPyArtProvider::Push(arg1);
20571 wxPyEndAllowThreads(__tstate);
20572 if (PyErr_Occurred()) SWIG_fail;
20573 }
20574 resultobj = SWIG_Py_Void();
20575 return resultobj;
20576 fail:
20577 return NULL;
20578 }
20579
20580
20581 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20582 PyObject *resultobj = 0;
20583 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20584 int res1 = 0 ;
20585 PyObject * obj0 = 0 ;
20586 char * kwnames[] = {
20587 (char *) "provider", NULL
20588 };
20589
20590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20591 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20592 if (!SWIG_IsOK(res1)) {
20593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20594 }
20595 {
20596 PyThreadState* __tstate = wxPyBeginAllowThreads();
20597 wxPyArtProvider::Insert(arg1);
20598 wxPyEndAllowThreads(__tstate);
20599 if (PyErr_Occurred()) SWIG_fail;
20600 }
20601 resultobj = SWIG_Py_Void();
20602 return resultobj;
20603 fail:
20604 return NULL;
20605 }
20606
20607
20608 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20609 PyObject *resultobj = 0;
20610 bool result;
20611
20612 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20613 {
20614 PyThreadState* __tstate = wxPyBeginAllowThreads();
20615 result = (bool)wxPyArtProvider::Pop();
20616 wxPyEndAllowThreads(__tstate);
20617 if (PyErr_Occurred()) SWIG_fail;
20618 }
20619 {
20620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20621 }
20622 return resultobj;
20623 fail:
20624 return NULL;
20625 }
20626
20627
20628 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20629 PyObject *resultobj = 0;
20630 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20631 bool result;
20632 void *argp1 = 0 ;
20633 int res1 = 0 ;
20634 PyObject * obj0 = 0 ;
20635 char * kwnames[] = {
20636 (char *) "provider", NULL
20637 };
20638
20639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20641 if (!SWIG_IsOK(res1)) {
20642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20643 }
20644 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20645 {
20646 PyThreadState* __tstate = wxPyBeginAllowThreads();
20647 result = (bool)wxPyArtProvider::Delete(arg1);
20648 wxPyEndAllowThreads(__tstate);
20649 if (PyErr_Occurred()) SWIG_fail;
20650 }
20651 {
20652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20653 }
20654 return resultobj;
20655 fail:
20656 return NULL;
20657 }
20658
20659
20660 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20661 PyObject *resultobj = 0;
20662 wxString *arg1 = 0 ;
20663 wxString const &arg2_defvalue = wxPyART_OTHER ;
20664 wxString *arg2 = (wxString *) &arg2_defvalue ;
20665 wxSize const &arg3_defvalue = wxDefaultSize ;
20666 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20667 wxBitmap result;
20668 bool temp1 = false ;
20669 bool temp2 = false ;
20670 wxSize temp3 ;
20671 PyObject * obj0 = 0 ;
20672 PyObject * obj1 = 0 ;
20673 PyObject * obj2 = 0 ;
20674 char * kwnames[] = {
20675 (char *) "id",(char *) "client",(char *) "size", NULL
20676 };
20677
20678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20679 {
20680 arg1 = wxString_in_helper(obj0);
20681 if (arg1 == NULL) SWIG_fail;
20682 temp1 = true;
20683 }
20684 if (obj1) {
20685 {
20686 arg2 = wxString_in_helper(obj1);
20687 if (arg2 == NULL) SWIG_fail;
20688 temp2 = true;
20689 }
20690 }
20691 if (obj2) {
20692 {
20693 arg3 = &temp3;
20694 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20695 }
20696 }
20697 {
20698 if (!wxPyCheckForApp()) SWIG_fail;
20699 PyThreadState* __tstate = wxPyBeginAllowThreads();
20700 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20701 wxPyEndAllowThreads(__tstate);
20702 if (PyErr_Occurred()) SWIG_fail;
20703 }
20704 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20705 {
20706 if (temp1)
20707 delete arg1;
20708 }
20709 {
20710 if (temp2)
20711 delete arg2;
20712 }
20713 return resultobj;
20714 fail:
20715 {
20716 if (temp1)
20717 delete arg1;
20718 }
20719 {
20720 if (temp2)
20721 delete arg2;
20722 }
20723 return NULL;
20724 }
20725
20726
20727 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20728 PyObject *resultobj = 0;
20729 wxString *arg1 = 0 ;
20730 wxString const &arg2_defvalue = wxPyART_OTHER ;
20731 wxString *arg2 = (wxString *) &arg2_defvalue ;
20732 wxSize const &arg3_defvalue = wxDefaultSize ;
20733 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20734 wxIcon result;
20735 bool temp1 = false ;
20736 bool temp2 = false ;
20737 wxSize temp3 ;
20738 PyObject * obj0 = 0 ;
20739 PyObject * obj1 = 0 ;
20740 PyObject * obj2 = 0 ;
20741 char * kwnames[] = {
20742 (char *) "id",(char *) "client",(char *) "size", NULL
20743 };
20744
20745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20746 {
20747 arg1 = wxString_in_helper(obj0);
20748 if (arg1 == NULL) SWIG_fail;
20749 temp1 = true;
20750 }
20751 if (obj1) {
20752 {
20753 arg2 = wxString_in_helper(obj1);
20754 if (arg2 == NULL) SWIG_fail;
20755 temp2 = true;
20756 }
20757 }
20758 if (obj2) {
20759 {
20760 arg3 = &temp3;
20761 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20762 }
20763 }
20764 {
20765 if (!wxPyCheckForApp()) SWIG_fail;
20766 PyThreadState* __tstate = wxPyBeginAllowThreads();
20767 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20768 wxPyEndAllowThreads(__tstate);
20769 if (PyErr_Occurred()) SWIG_fail;
20770 }
20771 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20772 {
20773 if (temp1)
20774 delete arg1;
20775 }
20776 {
20777 if (temp2)
20778 delete arg2;
20779 }
20780 return resultobj;
20781 fail:
20782 {
20783 if (temp1)
20784 delete arg1;
20785 }
20786 {
20787 if (temp2)
20788 delete arg2;
20789 }
20790 return NULL;
20791 }
20792
20793
20794 SWIGINTERN PyObject *_wrap_ArtProvider_GetIconBundle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20795 PyObject *resultobj = 0;
20796 wxArtID *arg1 = 0 ;
20797 wxArtClient const &arg2_defvalue = wxART_OTHER ;
20798 wxArtClient *arg2 = (wxArtClient *) &arg2_defvalue ;
20799 wxIconBundle result;
20800 void *argp1 = 0 ;
20801 int res1 = 0 ;
20802 void *argp2 = 0 ;
20803 int res2 = 0 ;
20804 PyObject * obj0 = 0 ;
20805 PyObject * obj1 = 0 ;
20806 char * kwnames[] = {
20807 (char *) "id",(char *) "client", NULL
20808 };
20809
20810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetIconBundle",kwnames,&obj0,&obj1)) SWIG_fail;
20811 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxArtID, 0 | 0);
20812 if (!SWIG_IsOK(res1)) {
20813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_GetIconBundle" "', expected argument " "1"" of type '" "wxArtID const &""'");
20814 }
20815 if (!argp1) {
20816 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArtProvider_GetIconBundle" "', expected argument " "1"" of type '" "wxArtID const &""'");
20817 }
20818 arg1 = reinterpret_cast< wxArtID * >(argp1);
20819 if (obj1) {
20820 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxArtClient, 0 | 0);
20821 if (!SWIG_IsOK(res2)) {
20822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArtProvider_GetIconBundle" "', expected argument " "2"" of type '" "wxArtClient const &""'");
20823 }
20824 if (!argp2) {
20825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArtProvider_GetIconBundle" "', expected argument " "2"" of type '" "wxArtClient const &""'");
20826 }
20827 arg2 = reinterpret_cast< wxArtClient * >(argp2);
20828 }
20829 {
20830 PyThreadState* __tstate = wxPyBeginAllowThreads();
20831 result = wxPyArtProvider::GetIconBundle((wxArtID const &)*arg1,(wxArtClient const &)*arg2);
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 resultobj = SWIG_NewPointerObj((new wxIconBundle(static_cast< const wxIconBundle& >(result))), SWIGTYPE_p_wxIconBundle, SWIG_POINTER_OWN | 0 );
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20843 PyObject *resultobj = 0;
20844 wxString *arg1 = 0 ;
20845 bool arg2 = (bool) false ;
20846 wxSize result;
20847 bool temp1 = false ;
20848 bool val2 ;
20849 int ecode2 = 0 ;
20850 PyObject * obj0 = 0 ;
20851 PyObject * obj1 = 0 ;
20852 char * kwnames[] = {
20853 (char *) "client",(char *) "platform_dependent", NULL
20854 };
20855
20856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20857 {
20858 arg1 = wxString_in_helper(obj0);
20859 if (arg1 == NULL) SWIG_fail;
20860 temp1 = true;
20861 }
20862 if (obj1) {
20863 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20864 if (!SWIG_IsOK(ecode2)) {
20865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20866 }
20867 arg2 = static_cast< bool >(val2);
20868 }
20869 {
20870 PyThreadState* __tstate = wxPyBeginAllowThreads();
20871 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20876 {
20877 if (temp1)
20878 delete arg1;
20879 }
20880 return resultobj;
20881 fail:
20882 {
20883 if (temp1)
20884 delete arg1;
20885 }
20886 return NULL;
20887 }
20888
20889
20890 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20891 PyObject *resultobj = 0;
20892 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20893 void *argp1 = 0 ;
20894 int res1 = 0 ;
20895 PyObject *swig_obj[1] ;
20896
20897 if (!args) SWIG_fail;
20898 swig_obj[0] = args;
20899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20900 if (!SWIG_IsOK(res1)) {
20901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20902 }
20903 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20904 {
20905 PyThreadState* __tstate = wxPyBeginAllowThreads();
20906 wxPyArtProvider_Destroy(arg1);
20907 wxPyEndAllowThreads(__tstate);
20908 if (PyErr_Occurred()) SWIG_fail;
20909 }
20910 resultobj = SWIG_Py_Void();
20911 return resultobj;
20912 fail:
20913 return NULL;
20914 }
20915
20916
20917 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20918 PyObject *obj;
20919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20920 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20921 return SWIG_Py_Void();
20922 }
20923
20924 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20925 return SWIG_Python_InitShadowInstance(args);
20926 }
20927
20928 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20929 PyObject *resultobj = 0;
20930 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20931 void *argp1 = 0 ;
20932 int res1 = 0 ;
20933 PyObject *swig_obj[1] ;
20934
20935 if (!args) SWIG_fail;
20936 swig_obj[0] = args;
20937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20938 if (!SWIG_IsOK(res1)) {
20939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20940 }
20941 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 delete arg1;
20945
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 resultobj = SWIG_Py_Void();
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20957 PyObject *resultobj = 0;
20958 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20959 wxConfigBase *result = 0 ;
20960 int res1 = 0 ;
20961 PyObject * obj0 = 0 ;
20962 char * kwnames[] = {
20963 (char *) "config", NULL
20964 };
20965
20966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20967 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20968 if (!SWIG_IsOK(res1)) {
20969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20970 }
20971 {
20972 PyThreadState* __tstate = wxPyBeginAllowThreads();
20973 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20978 return resultobj;
20979 fail:
20980 return NULL;
20981 }
20982
20983
20984 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20985 PyObject *resultobj = 0;
20986 bool arg1 = (bool) true ;
20987 wxConfigBase *result = 0 ;
20988 bool val1 ;
20989 int ecode1 = 0 ;
20990 PyObject * obj0 = 0 ;
20991 char * kwnames[] = {
20992 (char *) "createOnDemand", NULL
20993 };
20994
20995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20996 if (obj0) {
20997 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20998 if (!SWIG_IsOK(ecode1)) {
20999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
21000 }
21001 arg1 = static_cast< bool >(val1);
21002 }
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 result = (wxConfigBase *)wxConfigBase::Get(arg1);
21006 wxPyEndAllowThreads(__tstate);
21007 if (PyErr_Occurred()) SWIG_fail;
21008 }
21009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21017 PyObject *resultobj = 0;
21018 wxConfigBase *result = 0 ;
21019
21020 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
21021 {
21022 PyThreadState* __tstate = wxPyBeginAllowThreads();
21023 result = (wxConfigBase *)wxConfigBase::Create();
21024 wxPyEndAllowThreads(__tstate);
21025 if (PyErr_Occurred()) SWIG_fail;
21026 }
21027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
21028 return resultobj;
21029 fail:
21030 return NULL;
21031 }
21032
21033
21034 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21035 PyObject *resultobj = 0;
21036
21037 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 wxConfigBase::DontCreateOnDemand();
21041 wxPyEndAllowThreads(__tstate);
21042 if (PyErr_Occurred()) SWIG_fail;
21043 }
21044 resultobj = SWIG_Py_Void();
21045 return resultobj;
21046 fail:
21047 return NULL;
21048 }
21049
21050
21051 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21052 PyObject *resultobj = 0;
21053 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21054 wxString *arg2 = 0 ;
21055 void *argp1 = 0 ;
21056 int res1 = 0 ;
21057 bool temp2 = false ;
21058 PyObject * obj0 = 0 ;
21059 PyObject * obj1 = 0 ;
21060 char * kwnames[] = {
21061 (char *) "self",(char *) "path", NULL
21062 };
21063
21064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
21065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21066 if (!SWIG_IsOK(res1)) {
21067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21068 }
21069 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21070 {
21071 arg2 = wxString_in_helper(obj1);
21072 if (arg2 == NULL) SWIG_fail;
21073 temp2 = true;
21074 }
21075 {
21076 PyThreadState* __tstate = wxPyBeginAllowThreads();
21077 (arg1)->SetPath((wxString const &)*arg2);
21078 wxPyEndAllowThreads(__tstate);
21079 if (PyErr_Occurred()) SWIG_fail;
21080 }
21081 resultobj = SWIG_Py_Void();
21082 {
21083 if (temp2)
21084 delete arg2;
21085 }
21086 return resultobj;
21087 fail:
21088 {
21089 if (temp2)
21090 delete arg2;
21091 }
21092 return NULL;
21093 }
21094
21095
21096 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21097 PyObject *resultobj = 0;
21098 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21099 wxString *result = 0 ;
21100 void *argp1 = 0 ;
21101 int res1 = 0 ;
21102 PyObject *swig_obj[1] ;
21103
21104 if (!args) SWIG_fail;
21105 swig_obj[0] = args;
21106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21107 if (!SWIG_IsOK(res1)) {
21108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21109 }
21110 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21111 {
21112 PyThreadState* __tstate = wxPyBeginAllowThreads();
21113 {
21114 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21115 result = (wxString *) &_result_ref;
21116 }
21117 wxPyEndAllowThreads(__tstate);
21118 if (PyErr_Occurred()) SWIG_fail;
21119 }
21120 {
21121 #if wxUSE_UNICODE
21122 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21123 #else
21124 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21125 #endif
21126 }
21127 return resultobj;
21128 fail:
21129 return NULL;
21130 }
21131
21132
21133 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21134 PyObject *resultobj = 0;
21135 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21136 PyObject *result = 0 ;
21137 void *argp1 = 0 ;
21138 int res1 = 0 ;
21139 PyObject *swig_obj[1] ;
21140
21141 if (!args) SWIG_fail;
21142 swig_obj[0] = args;
21143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21144 if (!SWIG_IsOK(res1)) {
21145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21146 }
21147 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21148 {
21149 PyThreadState* __tstate = wxPyBeginAllowThreads();
21150 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21151 wxPyEndAllowThreads(__tstate);
21152 if (PyErr_Occurred()) SWIG_fail;
21153 }
21154 resultobj = result;
21155 return resultobj;
21156 fail:
21157 return NULL;
21158 }
21159
21160
21161 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21162 PyObject *resultobj = 0;
21163 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21164 long arg2 ;
21165 PyObject *result = 0 ;
21166 void *argp1 = 0 ;
21167 int res1 = 0 ;
21168 long val2 ;
21169 int ecode2 = 0 ;
21170 PyObject * obj0 = 0 ;
21171 PyObject * obj1 = 0 ;
21172 char * kwnames[] = {
21173 (char *) "self",(char *) "index", NULL
21174 };
21175
21176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21178 if (!SWIG_IsOK(res1)) {
21179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21180 }
21181 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21182 ecode2 = SWIG_AsVal_long(obj1, &val2);
21183 if (!SWIG_IsOK(ecode2)) {
21184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21185 }
21186 arg2 = static_cast< long >(val2);
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21190 wxPyEndAllowThreads(__tstate);
21191 if (PyErr_Occurred()) SWIG_fail;
21192 }
21193 resultobj = result;
21194 return resultobj;
21195 fail:
21196 return NULL;
21197 }
21198
21199
21200 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21201 PyObject *resultobj = 0;
21202 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21203 PyObject *result = 0 ;
21204 void *argp1 = 0 ;
21205 int res1 = 0 ;
21206 PyObject *swig_obj[1] ;
21207
21208 if (!args) SWIG_fail;
21209 swig_obj[0] = args;
21210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21211 if (!SWIG_IsOK(res1)) {
21212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21213 }
21214 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21215 {
21216 PyThreadState* __tstate = wxPyBeginAllowThreads();
21217 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 resultobj = result;
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21229 PyObject *resultobj = 0;
21230 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21231 long arg2 ;
21232 PyObject *result = 0 ;
21233 void *argp1 = 0 ;
21234 int res1 = 0 ;
21235 long val2 ;
21236 int ecode2 = 0 ;
21237 PyObject * obj0 = 0 ;
21238 PyObject * obj1 = 0 ;
21239 char * kwnames[] = {
21240 (char *) "self",(char *) "index", NULL
21241 };
21242
21243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21245 if (!SWIG_IsOK(res1)) {
21246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21247 }
21248 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21249 ecode2 = SWIG_AsVal_long(obj1, &val2);
21250 if (!SWIG_IsOK(ecode2)) {
21251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21252 }
21253 arg2 = static_cast< long >(val2);
21254 {
21255 PyThreadState* __tstate = wxPyBeginAllowThreads();
21256 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21257 wxPyEndAllowThreads(__tstate);
21258 if (PyErr_Occurred()) SWIG_fail;
21259 }
21260 resultobj = result;
21261 return resultobj;
21262 fail:
21263 return NULL;
21264 }
21265
21266
21267 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21268 PyObject *resultobj = 0;
21269 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21270 bool arg2 = (bool) false ;
21271 size_t result;
21272 void *argp1 = 0 ;
21273 int res1 = 0 ;
21274 bool val2 ;
21275 int ecode2 = 0 ;
21276 PyObject * obj0 = 0 ;
21277 PyObject * obj1 = 0 ;
21278 char * kwnames[] = {
21279 (char *) "self",(char *) "recursive", NULL
21280 };
21281
21282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21284 if (!SWIG_IsOK(res1)) {
21285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21286 }
21287 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21288 if (obj1) {
21289 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21290 if (!SWIG_IsOK(ecode2)) {
21291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21292 }
21293 arg2 = static_cast< bool >(val2);
21294 }
21295 {
21296 PyThreadState* __tstate = wxPyBeginAllowThreads();
21297 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21298 wxPyEndAllowThreads(__tstate);
21299 if (PyErr_Occurred()) SWIG_fail;
21300 }
21301 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21302 return resultobj;
21303 fail:
21304 return NULL;
21305 }
21306
21307
21308 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21309 PyObject *resultobj = 0;
21310 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21311 bool arg2 = (bool) false ;
21312 size_t result;
21313 void *argp1 = 0 ;
21314 int res1 = 0 ;
21315 bool val2 ;
21316 int ecode2 = 0 ;
21317 PyObject * obj0 = 0 ;
21318 PyObject * obj1 = 0 ;
21319 char * kwnames[] = {
21320 (char *) "self",(char *) "recursive", NULL
21321 };
21322
21323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21325 if (!SWIG_IsOK(res1)) {
21326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21327 }
21328 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21329 if (obj1) {
21330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21331 if (!SWIG_IsOK(ecode2)) {
21332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21333 }
21334 arg2 = static_cast< bool >(val2);
21335 }
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21339 wxPyEndAllowThreads(__tstate);
21340 if (PyErr_Occurred()) SWIG_fail;
21341 }
21342 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21343 return resultobj;
21344 fail:
21345 return NULL;
21346 }
21347
21348
21349 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21350 PyObject *resultobj = 0;
21351 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21352 wxString *arg2 = 0 ;
21353 bool result;
21354 void *argp1 = 0 ;
21355 int res1 = 0 ;
21356 bool temp2 = false ;
21357 PyObject * obj0 = 0 ;
21358 PyObject * obj1 = 0 ;
21359 char * kwnames[] = {
21360 (char *) "self",(char *) "name", NULL
21361 };
21362
21363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21365 if (!SWIG_IsOK(res1)) {
21366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21367 }
21368 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21369 {
21370 arg2 = wxString_in_helper(obj1);
21371 if (arg2 == NULL) SWIG_fail;
21372 temp2 = true;
21373 }
21374 {
21375 PyThreadState* __tstate = wxPyBeginAllowThreads();
21376 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21377 wxPyEndAllowThreads(__tstate);
21378 if (PyErr_Occurred()) SWIG_fail;
21379 }
21380 {
21381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21382 }
21383 {
21384 if (temp2)
21385 delete arg2;
21386 }
21387 return resultobj;
21388 fail:
21389 {
21390 if (temp2)
21391 delete arg2;
21392 }
21393 return NULL;
21394 }
21395
21396
21397 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21398 PyObject *resultobj = 0;
21399 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21400 wxString *arg2 = 0 ;
21401 bool result;
21402 void *argp1 = 0 ;
21403 int res1 = 0 ;
21404 bool temp2 = false ;
21405 PyObject * obj0 = 0 ;
21406 PyObject * obj1 = 0 ;
21407 char * kwnames[] = {
21408 (char *) "self",(char *) "name", NULL
21409 };
21410
21411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21413 if (!SWIG_IsOK(res1)) {
21414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21415 }
21416 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21417 {
21418 arg2 = wxString_in_helper(obj1);
21419 if (arg2 == NULL) SWIG_fail;
21420 temp2 = true;
21421 }
21422 {
21423 PyThreadState* __tstate = wxPyBeginAllowThreads();
21424 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21425 wxPyEndAllowThreads(__tstate);
21426 if (PyErr_Occurred()) SWIG_fail;
21427 }
21428 {
21429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21430 }
21431 {
21432 if (temp2)
21433 delete arg2;
21434 }
21435 return resultobj;
21436 fail:
21437 {
21438 if (temp2)
21439 delete arg2;
21440 }
21441 return NULL;
21442 }
21443
21444
21445 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21446 PyObject *resultobj = 0;
21447 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21448 wxString *arg2 = 0 ;
21449 bool result;
21450 void *argp1 = 0 ;
21451 int res1 = 0 ;
21452 bool temp2 = false ;
21453 PyObject * obj0 = 0 ;
21454 PyObject * obj1 = 0 ;
21455 char * kwnames[] = {
21456 (char *) "self",(char *) "name", NULL
21457 };
21458
21459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21461 if (!SWIG_IsOK(res1)) {
21462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21463 }
21464 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21465 {
21466 arg2 = wxString_in_helper(obj1);
21467 if (arg2 == NULL) SWIG_fail;
21468 temp2 = true;
21469 }
21470 {
21471 PyThreadState* __tstate = wxPyBeginAllowThreads();
21472 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21473 wxPyEndAllowThreads(__tstate);
21474 if (PyErr_Occurred()) SWIG_fail;
21475 }
21476 {
21477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21478 }
21479 {
21480 if (temp2)
21481 delete arg2;
21482 }
21483 return resultobj;
21484 fail:
21485 {
21486 if (temp2)
21487 delete arg2;
21488 }
21489 return NULL;
21490 }
21491
21492
21493 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21494 PyObject *resultobj = 0;
21495 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21496 wxString *arg2 = 0 ;
21497 wxConfigBase::EntryType result;
21498 void *argp1 = 0 ;
21499 int res1 = 0 ;
21500 bool temp2 = false ;
21501 PyObject * obj0 = 0 ;
21502 PyObject * obj1 = 0 ;
21503 char * kwnames[] = {
21504 (char *) "self",(char *) "name", NULL
21505 };
21506
21507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21509 if (!SWIG_IsOK(res1)) {
21510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21511 }
21512 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21513 {
21514 arg2 = wxString_in_helper(obj1);
21515 if (arg2 == NULL) SWIG_fail;
21516 temp2 = true;
21517 }
21518 {
21519 PyThreadState* __tstate = wxPyBeginAllowThreads();
21520 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21521 wxPyEndAllowThreads(__tstate);
21522 if (PyErr_Occurred()) SWIG_fail;
21523 }
21524 resultobj = SWIG_From_int(static_cast< int >(result));
21525 {
21526 if (temp2)
21527 delete arg2;
21528 }
21529 return resultobj;
21530 fail:
21531 {
21532 if (temp2)
21533 delete arg2;
21534 }
21535 return NULL;
21536 }
21537
21538
21539 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21540 PyObject *resultobj = 0;
21541 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21542 wxString *arg2 = 0 ;
21543 wxString const &arg3_defvalue = wxPyEmptyString ;
21544 wxString *arg3 = (wxString *) &arg3_defvalue ;
21545 wxString result;
21546 void *argp1 = 0 ;
21547 int res1 = 0 ;
21548 bool temp2 = false ;
21549 bool temp3 = false ;
21550 PyObject * obj0 = 0 ;
21551 PyObject * obj1 = 0 ;
21552 PyObject * obj2 = 0 ;
21553 char * kwnames[] = {
21554 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21555 };
21556
21557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21559 if (!SWIG_IsOK(res1)) {
21560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21561 }
21562 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21563 {
21564 arg2 = wxString_in_helper(obj1);
21565 if (arg2 == NULL) SWIG_fail;
21566 temp2 = true;
21567 }
21568 if (obj2) {
21569 {
21570 arg3 = wxString_in_helper(obj2);
21571 if (arg3 == NULL) SWIG_fail;
21572 temp3 = true;
21573 }
21574 }
21575 {
21576 PyThreadState* __tstate = wxPyBeginAllowThreads();
21577 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21578 wxPyEndAllowThreads(__tstate);
21579 if (PyErr_Occurred()) SWIG_fail;
21580 }
21581 {
21582 #if wxUSE_UNICODE
21583 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21584 #else
21585 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21586 #endif
21587 }
21588 {
21589 if (temp2)
21590 delete arg2;
21591 }
21592 {
21593 if (temp3)
21594 delete arg3;
21595 }
21596 return resultobj;
21597 fail:
21598 {
21599 if (temp2)
21600 delete arg2;
21601 }
21602 {
21603 if (temp3)
21604 delete arg3;
21605 }
21606 return NULL;
21607 }
21608
21609
21610 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21611 PyObject *resultobj = 0;
21612 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21613 wxString *arg2 = 0 ;
21614 long arg3 = (long) 0 ;
21615 long result;
21616 void *argp1 = 0 ;
21617 int res1 = 0 ;
21618 bool temp2 = false ;
21619 long val3 ;
21620 int ecode3 = 0 ;
21621 PyObject * obj0 = 0 ;
21622 PyObject * obj1 = 0 ;
21623 PyObject * obj2 = 0 ;
21624 char * kwnames[] = {
21625 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21626 };
21627
21628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21630 if (!SWIG_IsOK(res1)) {
21631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21632 }
21633 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21634 {
21635 arg2 = wxString_in_helper(obj1);
21636 if (arg2 == NULL) SWIG_fail;
21637 temp2 = true;
21638 }
21639 if (obj2) {
21640 ecode3 = SWIG_AsVal_long(obj2, &val3);
21641 if (!SWIG_IsOK(ecode3)) {
21642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21643 }
21644 arg3 = static_cast< long >(val3);
21645 }
21646 {
21647 PyThreadState* __tstate = wxPyBeginAllowThreads();
21648 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21649 wxPyEndAllowThreads(__tstate);
21650 if (PyErr_Occurred()) SWIG_fail;
21651 }
21652 resultobj = SWIG_From_long(static_cast< long >(result));
21653 {
21654 if (temp2)
21655 delete arg2;
21656 }
21657 return resultobj;
21658 fail:
21659 {
21660 if (temp2)
21661 delete arg2;
21662 }
21663 return NULL;
21664 }
21665
21666
21667 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21668 PyObject *resultobj = 0;
21669 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21670 wxString *arg2 = 0 ;
21671 double arg3 = (double) 0.0 ;
21672 double result;
21673 void *argp1 = 0 ;
21674 int res1 = 0 ;
21675 bool temp2 = false ;
21676 double val3 ;
21677 int ecode3 = 0 ;
21678 PyObject * obj0 = 0 ;
21679 PyObject * obj1 = 0 ;
21680 PyObject * obj2 = 0 ;
21681 char * kwnames[] = {
21682 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21683 };
21684
21685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21687 if (!SWIG_IsOK(res1)) {
21688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21689 }
21690 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21691 {
21692 arg2 = wxString_in_helper(obj1);
21693 if (arg2 == NULL) SWIG_fail;
21694 temp2 = true;
21695 }
21696 if (obj2) {
21697 ecode3 = SWIG_AsVal_double(obj2, &val3);
21698 if (!SWIG_IsOK(ecode3)) {
21699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21700 }
21701 arg3 = static_cast< double >(val3);
21702 }
21703 {
21704 PyThreadState* __tstate = wxPyBeginAllowThreads();
21705 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 resultobj = SWIG_From_double(static_cast< double >(result));
21710 {
21711 if (temp2)
21712 delete arg2;
21713 }
21714 return resultobj;
21715 fail:
21716 {
21717 if (temp2)
21718 delete arg2;
21719 }
21720 return NULL;
21721 }
21722
21723
21724 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21725 PyObject *resultobj = 0;
21726 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21727 wxString *arg2 = 0 ;
21728 bool arg3 = (bool) false ;
21729 bool result;
21730 void *argp1 = 0 ;
21731 int res1 = 0 ;
21732 bool temp2 = false ;
21733 bool val3 ;
21734 int ecode3 = 0 ;
21735 PyObject * obj0 = 0 ;
21736 PyObject * obj1 = 0 ;
21737 PyObject * obj2 = 0 ;
21738 char * kwnames[] = {
21739 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21740 };
21741
21742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21744 if (!SWIG_IsOK(res1)) {
21745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21746 }
21747 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21748 {
21749 arg2 = wxString_in_helper(obj1);
21750 if (arg2 == NULL) SWIG_fail;
21751 temp2 = true;
21752 }
21753 if (obj2) {
21754 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21755 if (!SWIG_IsOK(ecode3)) {
21756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21757 }
21758 arg3 = static_cast< bool >(val3);
21759 }
21760 {
21761 PyThreadState* __tstate = wxPyBeginAllowThreads();
21762 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 {
21767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21768 }
21769 {
21770 if (temp2)
21771 delete arg2;
21772 }
21773 return resultobj;
21774 fail:
21775 {
21776 if (temp2)
21777 delete arg2;
21778 }
21779 return NULL;
21780 }
21781
21782
21783 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21784 PyObject *resultobj = 0;
21785 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21786 wxString *arg2 = 0 ;
21787 wxString *arg3 = 0 ;
21788 bool result;
21789 void *argp1 = 0 ;
21790 int res1 = 0 ;
21791 bool temp2 = false ;
21792 bool temp3 = false ;
21793 PyObject * obj0 = 0 ;
21794 PyObject * obj1 = 0 ;
21795 PyObject * obj2 = 0 ;
21796 char * kwnames[] = {
21797 (char *) "self",(char *) "key",(char *) "value", NULL
21798 };
21799
21800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21802 if (!SWIG_IsOK(res1)) {
21803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21804 }
21805 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21806 {
21807 arg2 = wxString_in_helper(obj1);
21808 if (arg2 == NULL) SWIG_fail;
21809 temp2 = true;
21810 }
21811 {
21812 arg3 = wxString_in_helper(obj2);
21813 if (arg3 == NULL) SWIG_fail;
21814 temp3 = true;
21815 }
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 {
21823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21824 }
21825 {
21826 if (temp2)
21827 delete arg2;
21828 }
21829 {
21830 if (temp3)
21831 delete arg3;
21832 }
21833 return resultobj;
21834 fail:
21835 {
21836 if (temp2)
21837 delete arg2;
21838 }
21839 {
21840 if (temp3)
21841 delete arg3;
21842 }
21843 return NULL;
21844 }
21845
21846
21847 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21848 PyObject *resultobj = 0;
21849 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21850 wxString *arg2 = 0 ;
21851 long arg3 ;
21852 bool result;
21853 void *argp1 = 0 ;
21854 int res1 = 0 ;
21855 bool temp2 = false ;
21856 long val3 ;
21857 int ecode3 = 0 ;
21858 PyObject * obj0 = 0 ;
21859 PyObject * obj1 = 0 ;
21860 PyObject * obj2 = 0 ;
21861 char * kwnames[] = {
21862 (char *) "self",(char *) "key",(char *) "value", NULL
21863 };
21864
21865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21867 if (!SWIG_IsOK(res1)) {
21868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21869 }
21870 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21871 {
21872 arg2 = wxString_in_helper(obj1);
21873 if (arg2 == NULL) SWIG_fail;
21874 temp2 = true;
21875 }
21876 ecode3 = SWIG_AsVal_long(obj2, &val3);
21877 if (!SWIG_IsOK(ecode3)) {
21878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21879 }
21880 arg3 = static_cast< long >(val3);
21881 {
21882 PyThreadState* __tstate = wxPyBeginAllowThreads();
21883 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21884 wxPyEndAllowThreads(__tstate);
21885 if (PyErr_Occurred()) SWIG_fail;
21886 }
21887 {
21888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21889 }
21890 {
21891 if (temp2)
21892 delete arg2;
21893 }
21894 return resultobj;
21895 fail:
21896 {
21897 if (temp2)
21898 delete arg2;
21899 }
21900 return NULL;
21901 }
21902
21903
21904 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21905 PyObject *resultobj = 0;
21906 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21907 wxString *arg2 = 0 ;
21908 double arg3 ;
21909 bool result;
21910 void *argp1 = 0 ;
21911 int res1 = 0 ;
21912 bool temp2 = false ;
21913 double val3 ;
21914 int ecode3 = 0 ;
21915 PyObject * obj0 = 0 ;
21916 PyObject * obj1 = 0 ;
21917 PyObject * obj2 = 0 ;
21918 char * kwnames[] = {
21919 (char *) "self",(char *) "key",(char *) "value", NULL
21920 };
21921
21922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21924 if (!SWIG_IsOK(res1)) {
21925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21926 }
21927 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21928 {
21929 arg2 = wxString_in_helper(obj1);
21930 if (arg2 == NULL) SWIG_fail;
21931 temp2 = true;
21932 }
21933 ecode3 = SWIG_AsVal_double(obj2, &val3);
21934 if (!SWIG_IsOK(ecode3)) {
21935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21936 }
21937 arg3 = static_cast< double >(val3);
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21941 wxPyEndAllowThreads(__tstate);
21942 if (PyErr_Occurred()) SWIG_fail;
21943 }
21944 {
21945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21946 }
21947 {
21948 if (temp2)
21949 delete arg2;
21950 }
21951 return resultobj;
21952 fail:
21953 {
21954 if (temp2)
21955 delete arg2;
21956 }
21957 return NULL;
21958 }
21959
21960
21961 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21962 PyObject *resultobj = 0;
21963 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21964 wxString *arg2 = 0 ;
21965 bool arg3 ;
21966 bool result;
21967 void *argp1 = 0 ;
21968 int res1 = 0 ;
21969 bool temp2 = false ;
21970 bool val3 ;
21971 int ecode3 = 0 ;
21972 PyObject * obj0 = 0 ;
21973 PyObject * obj1 = 0 ;
21974 PyObject * obj2 = 0 ;
21975 char * kwnames[] = {
21976 (char *) "self",(char *) "key",(char *) "value", NULL
21977 };
21978
21979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21981 if (!SWIG_IsOK(res1)) {
21982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21983 }
21984 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21985 {
21986 arg2 = wxString_in_helper(obj1);
21987 if (arg2 == NULL) SWIG_fail;
21988 temp2 = true;
21989 }
21990 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21991 if (!SWIG_IsOK(ecode3)) {
21992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21993 }
21994 arg3 = static_cast< bool >(val3);
21995 {
21996 PyThreadState* __tstate = wxPyBeginAllowThreads();
21997 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21998 wxPyEndAllowThreads(__tstate);
21999 if (PyErr_Occurred()) SWIG_fail;
22000 }
22001 {
22002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22003 }
22004 {
22005 if (temp2)
22006 delete arg2;
22007 }
22008 return resultobj;
22009 fail:
22010 {
22011 if (temp2)
22012 delete arg2;
22013 }
22014 return NULL;
22015 }
22016
22017
22018 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22019 PyObject *resultobj = 0;
22020 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22021 bool arg2 = (bool) false ;
22022 bool result;
22023 void *argp1 = 0 ;
22024 int res1 = 0 ;
22025 bool val2 ;
22026 int ecode2 = 0 ;
22027 PyObject * obj0 = 0 ;
22028 PyObject * obj1 = 0 ;
22029 char * kwnames[] = {
22030 (char *) "self",(char *) "currentOnly", NULL
22031 };
22032
22033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
22034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22035 if (!SWIG_IsOK(res1)) {
22036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22037 }
22038 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22039 if (obj1) {
22040 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22041 if (!SWIG_IsOK(ecode2)) {
22042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
22043 }
22044 arg2 = static_cast< bool >(val2);
22045 }
22046 {
22047 PyThreadState* __tstate = wxPyBeginAllowThreads();
22048 result = (bool)(arg1)->Flush(arg2);
22049 wxPyEndAllowThreads(__tstate);
22050 if (PyErr_Occurred()) SWIG_fail;
22051 }
22052 {
22053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22054 }
22055 return resultobj;
22056 fail:
22057 return NULL;
22058 }
22059
22060
22061 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22062 PyObject *resultobj = 0;
22063 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22064 wxString *arg2 = 0 ;
22065 wxString *arg3 = 0 ;
22066 bool result;
22067 void *argp1 = 0 ;
22068 int res1 = 0 ;
22069 bool temp2 = false ;
22070 bool temp3 = false ;
22071 PyObject * obj0 = 0 ;
22072 PyObject * obj1 = 0 ;
22073 PyObject * obj2 = 0 ;
22074 char * kwnames[] = {
22075 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22076 };
22077
22078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22080 if (!SWIG_IsOK(res1)) {
22081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22082 }
22083 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22084 {
22085 arg2 = wxString_in_helper(obj1);
22086 if (arg2 == NULL) SWIG_fail;
22087 temp2 = true;
22088 }
22089 {
22090 arg3 = wxString_in_helper(obj2);
22091 if (arg3 == NULL) SWIG_fail;
22092 temp3 = true;
22093 }
22094 {
22095 PyThreadState* __tstate = wxPyBeginAllowThreads();
22096 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22097 wxPyEndAllowThreads(__tstate);
22098 if (PyErr_Occurred()) SWIG_fail;
22099 }
22100 {
22101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22102 }
22103 {
22104 if (temp2)
22105 delete arg2;
22106 }
22107 {
22108 if (temp3)
22109 delete arg3;
22110 }
22111 return resultobj;
22112 fail:
22113 {
22114 if (temp2)
22115 delete arg2;
22116 }
22117 {
22118 if (temp3)
22119 delete arg3;
22120 }
22121 return NULL;
22122 }
22123
22124
22125 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22126 PyObject *resultobj = 0;
22127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22128 wxString *arg2 = 0 ;
22129 wxString *arg3 = 0 ;
22130 bool result;
22131 void *argp1 = 0 ;
22132 int res1 = 0 ;
22133 bool temp2 = false ;
22134 bool temp3 = false ;
22135 PyObject * obj0 = 0 ;
22136 PyObject * obj1 = 0 ;
22137 PyObject * obj2 = 0 ;
22138 char * kwnames[] = {
22139 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22140 };
22141
22142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22144 if (!SWIG_IsOK(res1)) {
22145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22146 }
22147 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22148 {
22149 arg2 = wxString_in_helper(obj1);
22150 if (arg2 == NULL) SWIG_fail;
22151 temp2 = true;
22152 }
22153 {
22154 arg3 = wxString_in_helper(obj2);
22155 if (arg3 == NULL) SWIG_fail;
22156 temp3 = true;
22157 }
22158 {
22159 PyThreadState* __tstate = wxPyBeginAllowThreads();
22160 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22161 wxPyEndAllowThreads(__tstate);
22162 if (PyErr_Occurred()) SWIG_fail;
22163 }
22164 {
22165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22166 }
22167 {
22168 if (temp2)
22169 delete arg2;
22170 }
22171 {
22172 if (temp3)
22173 delete arg3;
22174 }
22175 return resultobj;
22176 fail:
22177 {
22178 if (temp2)
22179 delete arg2;
22180 }
22181 {
22182 if (temp3)
22183 delete arg3;
22184 }
22185 return NULL;
22186 }
22187
22188
22189 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj = 0;
22191 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22192 wxString *arg2 = 0 ;
22193 bool arg3 = (bool) true ;
22194 bool result;
22195 void *argp1 = 0 ;
22196 int res1 = 0 ;
22197 bool temp2 = false ;
22198 bool val3 ;
22199 int ecode3 = 0 ;
22200 PyObject * obj0 = 0 ;
22201 PyObject * obj1 = 0 ;
22202 PyObject * obj2 = 0 ;
22203 char * kwnames[] = {
22204 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22205 };
22206
22207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22209 if (!SWIG_IsOK(res1)) {
22210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22211 }
22212 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22213 {
22214 arg2 = wxString_in_helper(obj1);
22215 if (arg2 == NULL) SWIG_fail;
22216 temp2 = true;
22217 }
22218 if (obj2) {
22219 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22220 if (!SWIG_IsOK(ecode3)) {
22221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22222 }
22223 arg3 = static_cast< bool >(val3);
22224 }
22225 {
22226 PyThreadState* __tstate = wxPyBeginAllowThreads();
22227 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22228 wxPyEndAllowThreads(__tstate);
22229 if (PyErr_Occurred()) SWIG_fail;
22230 }
22231 {
22232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22233 }
22234 {
22235 if (temp2)
22236 delete arg2;
22237 }
22238 return resultobj;
22239 fail:
22240 {
22241 if (temp2)
22242 delete arg2;
22243 }
22244 return NULL;
22245 }
22246
22247
22248 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22249 PyObject *resultobj = 0;
22250 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22251 wxString *arg2 = 0 ;
22252 bool result;
22253 void *argp1 = 0 ;
22254 int res1 = 0 ;
22255 bool temp2 = false ;
22256 PyObject * obj0 = 0 ;
22257 PyObject * obj1 = 0 ;
22258 char * kwnames[] = {
22259 (char *) "self",(char *) "key", NULL
22260 };
22261
22262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22264 if (!SWIG_IsOK(res1)) {
22265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22266 }
22267 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22268 {
22269 arg2 = wxString_in_helper(obj1);
22270 if (arg2 == NULL) SWIG_fail;
22271 temp2 = true;
22272 }
22273 {
22274 PyThreadState* __tstate = wxPyBeginAllowThreads();
22275 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22276 wxPyEndAllowThreads(__tstate);
22277 if (PyErr_Occurred()) SWIG_fail;
22278 }
22279 {
22280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22281 }
22282 {
22283 if (temp2)
22284 delete arg2;
22285 }
22286 return resultobj;
22287 fail:
22288 {
22289 if (temp2)
22290 delete arg2;
22291 }
22292 return NULL;
22293 }
22294
22295
22296 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22297 PyObject *resultobj = 0;
22298 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22299 bool result;
22300 void *argp1 = 0 ;
22301 int res1 = 0 ;
22302 PyObject *swig_obj[1] ;
22303
22304 if (!args) SWIG_fail;
22305 swig_obj[0] = args;
22306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22307 if (!SWIG_IsOK(res1)) {
22308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22309 }
22310 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22311 {
22312 PyThreadState* __tstate = wxPyBeginAllowThreads();
22313 result = (bool)(arg1)->DeleteAll();
22314 wxPyEndAllowThreads(__tstate);
22315 if (PyErr_Occurred()) SWIG_fail;
22316 }
22317 {
22318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22319 }
22320 return resultobj;
22321 fail:
22322 return NULL;
22323 }
22324
22325
22326 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22327 PyObject *resultobj = 0;
22328 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22329 bool arg2 = (bool) true ;
22330 void *argp1 = 0 ;
22331 int res1 = 0 ;
22332 bool val2 ;
22333 int ecode2 = 0 ;
22334 PyObject * obj0 = 0 ;
22335 PyObject * obj1 = 0 ;
22336 char * kwnames[] = {
22337 (char *) "self",(char *) "doIt", NULL
22338 };
22339
22340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22342 if (!SWIG_IsOK(res1)) {
22343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22344 }
22345 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22346 if (obj1) {
22347 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22348 if (!SWIG_IsOK(ecode2)) {
22349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22350 }
22351 arg2 = static_cast< bool >(val2);
22352 }
22353 {
22354 PyThreadState* __tstate = wxPyBeginAllowThreads();
22355 (arg1)->SetExpandEnvVars(arg2);
22356 wxPyEndAllowThreads(__tstate);
22357 if (PyErr_Occurred()) SWIG_fail;
22358 }
22359 resultobj = SWIG_Py_Void();
22360 return resultobj;
22361 fail:
22362 return NULL;
22363 }
22364
22365
22366 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22367 PyObject *resultobj = 0;
22368 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22369 bool result;
22370 void *argp1 = 0 ;
22371 int res1 = 0 ;
22372 PyObject *swig_obj[1] ;
22373
22374 if (!args) SWIG_fail;
22375 swig_obj[0] = args;
22376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22377 if (!SWIG_IsOK(res1)) {
22378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22379 }
22380 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22381 {
22382 PyThreadState* __tstate = wxPyBeginAllowThreads();
22383 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22384 wxPyEndAllowThreads(__tstate);
22385 if (PyErr_Occurred()) SWIG_fail;
22386 }
22387 {
22388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22389 }
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22397 PyObject *resultobj = 0;
22398 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22399 bool arg2 = (bool) true ;
22400 void *argp1 = 0 ;
22401 int res1 = 0 ;
22402 bool val2 ;
22403 int ecode2 = 0 ;
22404 PyObject * obj0 = 0 ;
22405 PyObject * obj1 = 0 ;
22406 char * kwnames[] = {
22407 (char *) "self",(char *) "doIt", NULL
22408 };
22409
22410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22412 if (!SWIG_IsOK(res1)) {
22413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22414 }
22415 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22416 if (obj1) {
22417 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22418 if (!SWIG_IsOK(ecode2)) {
22419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22420 }
22421 arg2 = static_cast< bool >(val2);
22422 }
22423 {
22424 PyThreadState* __tstate = wxPyBeginAllowThreads();
22425 (arg1)->SetRecordDefaults(arg2);
22426 wxPyEndAllowThreads(__tstate);
22427 if (PyErr_Occurred()) SWIG_fail;
22428 }
22429 resultobj = SWIG_Py_Void();
22430 return resultobj;
22431 fail:
22432 return NULL;
22433 }
22434
22435
22436 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22437 PyObject *resultobj = 0;
22438 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22439 bool result;
22440 void *argp1 = 0 ;
22441 int res1 = 0 ;
22442 PyObject *swig_obj[1] ;
22443
22444 if (!args) SWIG_fail;
22445 swig_obj[0] = args;
22446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22447 if (!SWIG_IsOK(res1)) {
22448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22449 }
22450 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22451 {
22452 PyThreadState* __tstate = wxPyBeginAllowThreads();
22453 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22454 wxPyEndAllowThreads(__tstate);
22455 if (PyErr_Occurred()) SWIG_fail;
22456 }
22457 {
22458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22459 }
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22467 PyObject *resultobj = 0;
22468 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22469 wxString *arg2 = 0 ;
22470 wxString result;
22471 void *argp1 = 0 ;
22472 int res1 = 0 ;
22473 bool temp2 = false ;
22474 PyObject * obj0 = 0 ;
22475 PyObject * obj1 = 0 ;
22476 char * kwnames[] = {
22477 (char *) "self",(char *) "str", NULL
22478 };
22479
22480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22482 if (!SWIG_IsOK(res1)) {
22483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22484 }
22485 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22486 {
22487 arg2 = wxString_in_helper(obj1);
22488 if (arg2 == NULL) SWIG_fail;
22489 temp2 = true;
22490 }
22491 {
22492 PyThreadState* __tstate = wxPyBeginAllowThreads();
22493 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22494 wxPyEndAllowThreads(__tstate);
22495 if (PyErr_Occurred()) SWIG_fail;
22496 }
22497 {
22498 #if wxUSE_UNICODE
22499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22500 #else
22501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22502 #endif
22503 }
22504 {
22505 if (temp2)
22506 delete arg2;
22507 }
22508 return resultobj;
22509 fail:
22510 {
22511 if (temp2)
22512 delete arg2;
22513 }
22514 return NULL;
22515 }
22516
22517
22518 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22519 PyObject *resultobj = 0;
22520 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22521 wxString result;
22522 void *argp1 = 0 ;
22523 int res1 = 0 ;
22524 PyObject *swig_obj[1] ;
22525
22526 if (!args) SWIG_fail;
22527 swig_obj[0] = args;
22528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22529 if (!SWIG_IsOK(res1)) {
22530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22531 }
22532 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22533 {
22534 PyThreadState* __tstate = wxPyBeginAllowThreads();
22535 result = ((wxConfigBase const *)arg1)->GetAppName();
22536 wxPyEndAllowThreads(__tstate);
22537 if (PyErr_Occurred()) SWIG_fail;
22538 }
22539 {
22540 #if wxUSE_UNICODE
22541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22542 #else
22543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22544 #endif
22545 }
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22553 PyObject *resultobj = 0;
22554 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22555 wxString result;
22556 void *argp1 = 0 ;
22557 int res1 = 0 ;
22558 PyObject *swig_obj[1] ;
22559
22560 if (!args) SWIG_fail;
22561 swig_obj[0] = args;
22562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22563 if (!SWIG_IsOK(res1)) {
22564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22565 }
22566 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22567 {
22568 PyThreadState* __tstate = wxPyBeginAllowThreads();
22569 result = ((wxConfigBase const *)arg1)->GetVendorName();
22570 wxPyEndAllowThreads(__tstate);
22571 if (PyErr_Occurred()) SWIG_fail;
22572 }
22573 {
22574 #if wxUSE_UNICODE
22575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22576 #else
22577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22578 #endif
22579 }
22580 return resultobj;
22581 fail:
22582 return NULL;
22583 }
22584
22585
22586 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22587 PyObject *resultobj = 0;
22588 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22589 wxString *arg2 = 0 ;
22590 void *argp1 = 0 ;
22591 int res1 = 0 ;
22592 bool temp2 = false ;
22593 PyObject * obj0 = 0 ;
22594 PyObject * obj1 = 0 ;
22595 char * kwnames[] = {
22596 (char *) "self",(char *) "appName", NULL
22597 };
22598
22599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22601 if (!SWIG_IsOK(res1)) {
22602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22603 }
22604 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22605 {
22606 arg2 = wxString_in_helper(obj1);
22607 if (arg2 == NULL) SWIG_fail;
22608 temp2 = true;
22609 }
22610 {
22611 PyThreadState* __tstate = wxPyBeginAllowThreads();
22612 (arg1)->SetAppName((wxString const &)*arg2);
22613 wxPyEndAllowThreads(__tstate);
22614 if (PyErr_Occurred()) SWIG_fail;
22615 }
22616 resultobj = SWIG_Py_Void();
22617 {
22618 if (temp2)
22619 delete arg2;
22620 }
22621 return resultobj;
22622 fail:
22623 {
22624 if (temp2)
22625 delete arg2;
22626 }
22627 return NULL;
22628 }
22629
22630
22631 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22632 PyObject *resultobj = 0;
22633 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22634 wxString *arg2 = 0 ;
22635 void *argp1 = 0 ;
22636 int res1 = 0 ;
22637 bool temp2 = false ;
22638 PyObject * obj0 = 0 ;
22639 PyObject * obj1 = 0 ;
22640 char * kwnames[] = {
22641 (char *) "self",(char *) "vendorName", NULL
22642 };
22643
22644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22646 if (!SWIG_IsOK(res1)) {
22647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22648 }
22649 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22650 {
22651 arg2 = wxString_in_helper(obj1);
22652 if (arg2 == NULL) SWIG_fail;
22653 temp2 = true;
22654 }
22655 {
22656 PyThreadState* __tstate = wxPyBeginAllowThreads();
22657 (arg1)->SetVendorName((wxString const &)*arg2);
22658 wxPyEndAllowThreads(__tstate);
22659 if (PyErr_Occurred()) SWIG_fail;
22660 }
22661 resultobj = SWIG_Py_Void();
22662 {
22663 if (temp2)
22664 delete arg2;
22665 }
22666 return resultobj;
22667 fail:
22668 {
22669 if (temp2)
22670 delete arg2;
22671 }
22672 return NULL;
22673 }
22674
22675
22676 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22677 PyObject *resultobj = 0;
22678 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22679 long arg2 ;
22680 void *argp1 = 0 ;
22681 int res1 = 0 ;
22682 long val2 ;
22683 int ecode2 = 0 ;
22684 PyObject * obj0 = 0 ;
22685 PyObject * obj1 = 0 ;
22686 char * kwnames[] = {
22687 (char *) "self",(char *) "style", NULL
22688 };
22689
22690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22692 if (!SWIG_IsOK(res1)) {
22693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22694 }
22695 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22696 ecode2 = SWIG_AsVal_long(obj1, &val2);
22697 if (!SWIG_IsOK(ecode2)) {
22698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22699 }
22700 arg2 = static_cast< long >(val2);
22701 {
22702 PyThreadState* __tstate = wxPyBeginAllowThreads();
22703 (arg1)->SetStyle(arg2);
22704 wxPyEndAllowThreads(__tstate);
22705 if (PyErr_Occurred()) SWIG_fail;
22706 }
22707 resultobj = SWIG_Py_Void();
22708 return resultobj;
22709 fail:
22710 return NULL;
22711 }
22712
22713
22714 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22715 PyObject *resultobj = 0;
22716 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22717 long result;
22718 void *argp1 = 0 ;
22719 int res1 = 0 ;
22720 PyObject *swig_obj[1] ;
22721
22722 if (!args) SWIG_fail;
22723 swig_obj[0] = args;
22724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22725 if (!SWIG_IsOK(res1)) {
22726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22727 }
22728 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22729 {
22730 PyThreadState* __tstate = wxPyBeginAllowThreads();
22731 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22732 wxPyEndAllowThreads(__tstate);
22733 if (PyErr_Occurred()) SWIG_fail;
22734 }
22735 resultobj = SWIG_From_long(static_cast< long >(result));
22736 return resultobj;
22737 fail:
22738 return NULL;
22739 }
22740
22741
22742 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22743 PyObject *obj;
22744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22745 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22746 return SWIG_Py_Void();
22747 }
22748
22749 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22750 PyObject *resultobj = 0;
22751 wxString const &arg1_defvalue = wxPyEmptyString ;
22752 wxString *arg1 = (wxString *) &arg1_defvalue ;
22753 wxString const &arg2_defvalue = wxPyEmptyString ;
22754 wxString *arg2 = (wxString *) &arg2_defvalue ;
22755 wxString const &arg3_defvalue = wxPyEmptyString ;
22756 wxString *arg3 = (wxString *) &arg3_defvalue ;
22757 wxString const &arg4_defvalue = wxPyEmptyString ;
22758 wxString *arg4 = (wxString *) &arg4_defvalue ;
22759 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22760 wxConfig *result = 0 ;
22761 bool temp1 = false ;
22762 bool temp2 = false ;
22763 bool temp3 = false ;
22764 bool temp4 = false ;
22765 long val5 ;
22766 int ecode5 = 0 ;
22767 PyObject * obj0 = 0 ;
22768 PyObject * obj1 = 0 ;
22769 PyObject * obj2 = 0 ;
22770 PyObject * obj3 = 0 ;
22771 PyObject * obj4 = 0 ;
22772 char * kwnames[] = {
22773 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22774 };
22775
22776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22777 if (obj0) {
22778 {
22779 arg1 = wxString_in_helper(obj0);
22780 if (arg1 == NULL) SWIG_fail;
22781 temp1 = true;
22782 }
22783 }
22784 if (obj1) {
22785 {
22786 arg2 = wxString_in_helper(obj1);
22787 if (arg2 == NULL) SWIG_fail;
22788 temp2 = true;
22789 }
22790 }
22791 if (obj2) {
22792 {
22793 arg3 = wxString_in_helper(obj2);
22794 if (arg3 == NULL) SWIG_fail;
22795 temp3 = true;
22796 }
22797 }
22798 if (obj3) {
22799 {
22800 arg4 = wxString_in_helper(obj3);
22801 if (arg4 == NULL) SWIG_fail;
22802 temp4 = true;
22803 }
22804 }
22805 if (obj4) {
22806 ecode5 = SWIG_AsVal_long(obj4, &val5);
22807 if (!SWIG_IsOK(ecode5)) {
22808 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22809 }
22810 arg5 = static_cast< long >(val5);
22811 }
22812 {
22813 PyThreadState* __tstate = wxPyBeginAllowThreads();
22814 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22815 wxPyEndAllowThreads(__tstate);
22816 if (PyErr_Occurred()) SWIG_fail;
22817 }
22818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22819 {
22820 if (temp1)
22821 delete arg1;
22822 }
22823 {
22824 if (temp2)
22825 delete arg2;
22826 }
22827 {
22828 if (temp3)
22829 delete arg3;
22830 }
22831 {
22832 if (temp4)
22833 delete arg4;
22834 }
22835 return resultobj;
22836 fail:
22837 {
22838 if (temp1)
22839 delete arg1;
22840 }
22841 {
22842 if (temp2)
22843 delete arg2;
22844 }
22845 {
22846 if (temp3)
22847 delete arg3;
22848 }
22849 {
22850 if (temp4)
22851 delete arg4;
22852 }
22853 return NULL;
22854 }
22855
22856
22857 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22858 PyObject *resultobj = 0;
22859 wxConfig *arg1 = (wxConfig *) 0 ;
22860 void *argp1 = 0 ;
22861 int res1 = 0 ;
22862 PyObject *swig_obj[1] ;
22863
22864 if (!args) SWIG_fail;
22865 swig_obj[0] = args;
22866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22867 if (!SWIG_IsOK(res1)) {
22868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22869 }
22870 arg1 = reinterpret_cast< wxConfig * >(argp1);
22871 {
22872 PyThreadState* __tstate = wxPyBeginAllowThreads();
22873 delete arg1;
22874
22875 wxPyEndAllowThreads(__tstate);
22876 if (PyErr_Occurred()) SWIG_fail;
22877 }
22878 resultobj = SWIG_Py_Void();
22879 return resultobj;
22880 fail:
22881 return NULL;
22882 }
22883
22884
22885 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22886 PyObject *obj;
22887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22888 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22889 return SWIG_Py_Void();
22890 }
22891
22892 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22893 return SWIG_Python_InitShadowInstance(args);
22894 }
22895
22896 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22897 PyObject *resultobj = 0;
22898 wxString const &arg1_defvalue = wxPyEmptyString ;
22899 wxString *arg1 = (wxString *) &arg1_defvalue ;
22900 wxString const &arg2_defvalue = wxPyEmptyString ;
22901 wxString *arg2 = (wxString *) &arg2_defvalue ;
22902 wxString const &arg3_defvalue = wxPyEmptyString ;
22903 wxString *arg3 = (wxString *) &arg3_defvalue ;
22904 wxString const &arg4_defvalue = wxPyEmptyString ;
22905 wxString *arg4 = (wxString *) &arg4_defvalue ;
22906 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22907 wxFileConfig *result = 0 ;
22908 bool temp1 = false ;
22909 bool temp2 = false ;
22910 bool temp3 = false ;
22911 bool temp4 = false ;
22912 long val5 ;
22913 int ecode5 = 0 ;
22914 PyObject * obj0 = 0 ;
22915 PyObject * obj1 = 0 ;
22916 PyObject * obj2 = 0 ;
22917 PyObject * obj3 = 0 ;
22918 PyObject * obj4 = 0 ;
22919 char * kwnames[] = {
22920 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22921 };
22922
22923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22924 if (obj0) {
22925 {
22926 arg1 = wxString_in_helper(obj0);
22927 if (arg1 == NULL) SWIG_fail;
22928 temp1 = true;
22929 }
22930 }
22931 if (obj1) {
22932 {
22933 arg2 = wxString_in_helper(obj1);
22934 if (arg2 == NULL) SWIG_fail;
22935 temp2 = true;
22936 }
22937 }
22938 if (obj2) {
22939 {
22940 arg3 = wxString_in_helper(obj2);
22941 if (arg3 == NULL) SWIG_fail;
22942 temp3 = true;
22943 }
22944 }
22945 if (obj3) {
22946 {
22947 arg4 = wxString_in_helper(obj3);
22948 if (arg4 == NULL) SWIG_fail;
22949 temp4 = true;
22950 }
22951 }
22952 if (obj4) {
22953 ecode5 = SWIG_AsVal_long(obj4, &val5);
22954 if (!SWIG_IsOK(ecode5)) {
22955 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22956 }
22957 arg5 = static_cast< long >(val5);
22958 }
22959 {
22960 PyThreadState* __tstate = wxPyBeginAllowThreads();
22961 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22962 wxPyEndAllowThreads(__tstate);
22963 if (PyErr_Occurred()) SWIG_fail;
22964 }
22965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22966 {
22967 if (temp1)
22968 delete arg1;
22969 }
22970 {
22971 if (temp2)
22972 delete arg2;
22973 }
22974 {
22975 if (temp3)
22976 delete arg3;
22977 }
22978 {
22979 if (temp4)
22980 delete arg4;
22981 }
22982 return resultobj;
22983 fail:
22984 {
22985 if (temp1)
22986 delete arg1;
22987 }
22988 {
22989 if (temp2)
22990 delete arg2;
22991 }
22992 {
22993 if (temp3)
22994 delete arg3;
22995 }
22996 {
22997 if (temp4)
22998 delete arg4;
22999 }
23000 return NULL;
23001 }
23002
23003
23004 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23005 PyObject *resultobj = 0;
23006 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
23007 void *argp1 = 0 ;
23008 int res1 = 0 ;
23009 PyObject *swig_obj[1] ;
23010
23011 if (!args) SWIG_fail;
23012 swig_obj[0] = args;
23013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
23014 if (!SWIG_IsOK(res1)) {
23015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
23016 }
23017 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
23018 {
23019 PyThreadState* __tstate = wxPyBeginAllowThreads();
23020 delete arg1;
23021
23022 wxPyEndAllowThreads(__tstate);
23023 if (PyErr_Occurred()) SWIG_fail;
23024 }
23025 resultobj = SWIG_Py_Void();
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 SWIGINTERN PyObject *_wrap_FileConfig_GetGlobalFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23033 PyObject *resultobj = 0;
23034 wxString *arg1 = 0 ;
23035 wxString result;
23036 bool temp1 = false ;
23037 PyObject * obj0 = 0 ;
23038 char * kwnames[] = {
23039 (char *) "szFile", NULL
23040 };
23041
23042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileConfig_GetGlobalFileName",kwnames,&obj0)) SWIG_fail;
23043 {
23044 arg1 = wxString_in_helper(obj0);
23045 if (arg1 == NULL) SWIG_fail;
23046 temp1 = true;
23047 }
23048 {
23049 PyThreadState* __tstate = wxPyBeginAllowThreads();
23050 result = wxFileConfig::GetGlobalFileName((wxString const &)*arg1);
23051 wxPyEndAllowThreads(__tstate);
23052 if (PyErr_Occurred()) SWIG_fail;
23053 }
23054 {
23055 #if wxUSE_UNICODE
23056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23057 #else
23058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23059 #endif
23060 }
23061 {
23062 if (temp1)
23063 delete arg1;
23064 }
23065 return resultobj;
23066 fail:
23067 {
23068 if (temp1)
23069 delete arg1;
23070 }
23071 return NULL;
23072 }
23073
23074
23075 SWIGINTERN PyObject *_wrap_FileConfig_GetLocalFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23076 PyObject *resultobj = 0;
23077 wxString *arg1 = 0 ;
23078 int arg2 = (int) 0 ;
23079 wxString result;
23080 bool temp1 = false ;
23081 int val2 ;
23082 int ecode2 = 0 ;
23083 PyObject * obj0 = 0 ;
23084 PyObject * obj1 = 0 ;
23085 char * kwnames[] = {
23086 (char *) "szFile",(char *) "style", NULL
23087 };
23088
23089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FileConfig_GetLocalFileName",kwnames,&obj0,&obj1)) SWIG_fail;
23090 {
23091 arg1 = wxString_in_helper(obj0);
23092 if (arg1 == NULL) SWIG_fail;
23093 temp1 = true;
23094 }
23095 if (obj1) {
23096 ecode2 = SWIG_AsVal_int(obj1, &val2);
23097 if (!SWIG_IsOK(ecode2)) {
23098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileConfig_GetLocalFileName" "', expected argument " "2"" of type '" "int""'");
23099 }
23100 arg2 = static_cast< int >(val2);
23101 }
23102 {
23103 PyThreadState* __tstate = wxPyBeginAllowThreads();
23104 result = wxFileConfig::GetLocalFileName((wxString const &)*arg1,arg2);
23105 wxPyEndAllowThreads(__tstate);
23106 if (PyErr_Occurred()) SWIG_fail;
23107 }
23108 {
23109 #if wxUSE_UNICODE
23110 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23111 #else
23112 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23113 #endif
23114 }
23115 {
23116 if (temp1)
23117 delete arg1;
23118 }
23119 return resultobj;
23120 fail:
23121 {
23122 if (temp1)
23123 delete arg1;
23124 }
23125 return NULL;
23126 }
23127
23128
23129 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23130 PyObject *obj;
23131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23132 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
23133 return SWIG_Py_Void();
23134 }
23135
23136 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23137 return SWIG_Python_InitShadowInstance(args);
23138 }
23139
23140 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23141 PyObject *resultobj = 0;
23142 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
23143 wxString *arg2 = 0 ;
23144 wxConfigPathChanger *result = 0 ;
23145 void *argp1 = 0 ;
23146 int res1 = 0 ;
23147 bool temp2 = false ;
23148 PyObject * obj0 = 0 ;
23149 PyObject * obj1 = 0 ;
23150 char * kwnames[] = {
23151 (char *) "config",(char *) "entry", NULL
23152 };
23153
23154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
23155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
23156 if (!SWIG_IsOK(res1)) {
23157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
23158 }
23159 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
23160 {
23161 arg2 = wxString_in_helper(obj1);
23162 if (arg2 == NULL) SWIG_fail;
23163 temp2 = true;
23164 }
23165 {
23166 PyThreadState* __tstate = wxPyBeginAllowThreads();
23167 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23168 wxPyEndAllowThreads(__tstate);
23169 if (PyErr_Occurred()) SWIG_fail;
23170 }
23171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23172 {
23173 if (temp2)
23174 delete arg2;
23175 }
23176 return resultobj;
23177 fail:
23178 {
23179 if (temp2)
23180 delete arg2;
23181 }
23182 return NULL;
23183 }
23184
23185
23186 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23187 PyObject *resultobj = 0;
23188 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23189 void *argp1 = 0 ;
23190 int res1 = 0 ;
23191 PyObject *swig_obj[1] ;
23192
23193 if (!args) SWIG_fail;
23194 swig_obj[0] = args;
23195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23196 if (!SWIG_IsOK(res1)) {
23197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23198 }
23199 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23200 {
23201 PyThreadState* __tstate = wxPyBeginAllowThreads();
23202 delete arg1;
23203
23204 wxPyEndAllowThreads(__tstate);
23205 if (PyErr_Occurred()) SWIG_fail;
23206 }
23207 resultobj = SWIG_Py_Void();
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23215 PyObject *resultobj = 0;
23216 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23217 wxString *result = 0 ;
23218 void *argp1 = 0 ;
23219 int res1 = 0 ;
23220 PyObject *swig_obj[1] ;
23221
23222 if (!args) SWIG_fail;
23223 swig_obj[0] = args;
23224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23225 if (!SWIG_IsOK(res1)) {
23226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23227 }
23228 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23229 {
23230 PyThreadState* __tstate = wxPyBeginAllowThreads();
23231 {
23232 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23233 result = (wxString *) &_result_ref;
23234 }
23235 wxPyEndAllowThreads(__tstate);
23236 if (PyErr_Occurred()) SWIG_fail;
23237 }
23238 {
23239 #if wxUSE_UNICODE
23240 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23241 #else
23242 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23243 #endif
23244 }
23245 return resultobj;
23246 fail:
23247 return NULL;
23248 }
23249
23250
23251 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23252 PyObject *obj;
23253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23254 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23255 return SWIG_Py_Void();
23256 }
23257
23258 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23259 return SWIG_Python_InitShadowInstance(args);
23260 }
23261
23262 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23263 PyObject *resultobj = 0;
23264 wxString *arg1 = 0 ;
23265 wxString result;
23266 bool temp1 = false ;
23267 PyObject * obj0 = 0 ;
23268 char * kwnames[] = {
23269 (char *) "sz", NULL
23270 };
23271
23272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23273 {
23274 arg1 = wxString_in_helper(obj0);
23275 if (arg1 == NULL) SWIG_fail;
23276 temp1 = true;
23277 }
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 result = wxExpandEnvVars((wxString const &)*arg1);
23281 wxPyEndAllowThreads(__tstate);
23282 if (PyErr_Occurred()) SWIG_fail;
23283 }
23284 {
23285 #if wxUSE_UNICODE
23286 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23287 #else
23288 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23289 #endif
23290 }
23291 {
23292 if (temp1)
23293 delete arg1;
23294 }
23295 return resultobj;
23296 fail:
23297 {
23298 if (temp1)
23299 delete arg1;
23300 }
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23306 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23307 return 1;
23308 }
23309
23310
23311 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23312 PyObject *pyobj = 0;
23313
23314 {
23315 #if wxUSE_UNICODE
23316 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23317 #else
23318 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23319 #endif
23320 }
23321 return pyobj;
23322 }
23323
23324
23325 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23326 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23327 return 1;
23328 }
23329
23330
23331 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23332 PyObject *pyobj = 0;
23333
23334 {
23335 #if wxUSE_UNICODE
23336 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23337 #else
23338 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23339 #endif
23340 }
23341 return pyobj;
23342 }
23343
23344
23345 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23346 PyObject *resultobj = 0;
23347 wxDateTime::Country arg1 ;
23348 int val1 ;
23349 int ecode1 = 0 ;
23350 PyObject * obj0 = 0 ;
23351 char * kwnames[] = {
23352 (char *) "country", NULL
23353 };
23354
23355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23356 ecode1 = SWIG_AsVal_int(obj0, &val1);
23357 if (!SWIG_IsOK(ecode1)) {
23358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23359 }
23360 arg1 = static_cast< wxDateTime::Country >(val1);
23361 {
23362 PyThreadState* __tstate = wxPyBeginAllowThreads();
23363 wxDateTime::SetCountry(arg1);
23364 wxPyEndAllowThreads(__tstate);
23365 if (PyErr_Occurred()) SWIG_fail;
23366 }
23367 resultobj = SWIG_Py_Void();
23368 return resultobj;
23369 fail:
23370 return NULL;
23371 }
23372
23373
23374 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23375 PyObject *resultobj = 0;
23376 wxDateTime::Country result;
23377
23378 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23379 {
23380 PyThreadState* __tstate = wxPyBeginAllowThreads();
23381 result = (wxDateTime::Country)wxDateTime::GetCountry();
23382 wxPyEndAllowThreads(__tstate);
23383 if (PyErr_Occurred()) SWIG_fail;
23384 }
23385 resultobj = SWIG_From_int(static_cast< int >(result));
23386 return resultobj;
23387 fail:
23388 return NULL;
23389 }
23390
23391
23392 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23393 PyObject *resultobj = 0;
23394 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23395 bool result;
23396 int val1 ;
23397 int ecode1 = 0 ;
23398 PyObject * obj0 = 0 ;
23399 char * kwnames[] = {
23400 (char *) "country", NULL
23401 };
23402
23403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23404 if (obj0) {
23405 ecode1 = SWIG_AsVal_int(obj0, &val1);
23406 if (!SWIG_IsOK(ecode1)) {
23407 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23408 }
23409 arg1 = static_cast< wxDateTime::Country >(val1);
23410 }
23411 {
23412 PyThreadState* __tstate = wxPyBeginAllowThreads();
23413 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 {
23418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23419 }
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23427 PyObject *resultobj = 0;
23428 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23429 int result;
23430 int val1 ;
23431 int ecode1 = 0 ;
23432 PyObject * obj0 = 0 ;
23433 char * kwnames[] = {
23434 (char *) "cal", NULL
23435 };
23436
23437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23438 if (obj0) {
23439 ecode1 = SWIG_AsVal_int(obj0, &val1);
23440 if (!SWIG_IsOK(ecode1)) {
23441 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23442 }
23443 arg1 = static_cast< wxDateTime::Calendar >(val1);
23444 }
23445 {
23446 PyThreadState* __tstate = wxPyBeginAllowThreads();
23447 result = (int)wxDateTime::GetCurrentYear(arg1);
23448 wxPyEndAllowThreads(__tstate);
23449 if (PyErr_Occurred()) SWIG_fail;
23450 }
23451 resultobj = SWIG_From_int(static_cast< int >(result));
23452 return resultobj;
23453 fail:
23454 return NULL;
23455 }
23456
23457
23458 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23459 PyObject *resultobj = 0;
23460 int arg1 ;
23461 int result;
23462 int val1 ;
23463 int ecode1 = 0 ;
23464 PyObject * obj0 = 0 ;
23465 char * kwnames[] = {
23466 (char *) "year", NULL
23467 };
23468
23469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23470 ecode1 = SWIG_AsVal_int(obj0, &val1);
23471 if (!SWIG_IsOK(ecode1)) {
23472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23473 }
23474 arg1 = static_cast< int >(val1);
23475 {
23476 PyThreadState* __tstate = wxPyBeginAllowThreads();
23477 result = (int)wxDateTime::ConvertYearToBC(arg1);
23478 wxPyEndAllowThreads(__tstate);
23479 if (PyErr_Occurred()) SWIG_fail;
23480 }
23481 resultobj = SWIG_From_int(static_cast< int >(result));
23482 return resultobj;
23483 fail:
23484 return NULL;
23485 }
23486
23487
23488 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23489 PyObject *resultobj = 0;
23490 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23491 wxDateTime::Month result;
23492 int val1 ;
23493 int ecode1 = 0 ;
23494 PyObject * obj0 = 0 ;
23495 char * kwnames[] = {
23496 (char *) "cal", NULL
23497 };
23498
23499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23500 if (obj0) {
23501 ecode1 = SWIG_AsVal_int(obj0, &val1);
23502 if (!SWIG_IsOK(ecode1)) {
23503 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23504 }
23505 arg1 = static_cast< wxDateTime::Calendar >(val1);
23506 }
23507 {
23508 PyThreadState* __tstate = wxPyBeginAllowThreads();
23509 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23510 wxPyEndAllowThreads(__tstate);
23511 if (PyErr_Occurred()) SWIG_fail;
23512 }
23513 resultobj = SWIG_From_int(static_cast< int >(result));
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23521 PyObject *resultobj = 0;
23522 int arg1 = (int) wxDateTime::Inv_Year ;
23523 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23524 bool result;
23525 int val1 ;
23526 int ecode1 = 0 ;
23527 int val2 ;
23528 int ecode2 = 0 ;
23529 PyObject * obj0 = 0 ;
23530 PyObject * obj1 = 0 ;
23531 char * kwnames[] = {
23532 (char *) "year",(char *) "cal", NULL
23533 };
23534
23535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23536 if (obj0) {
23537 ecode1 = SWIG_AsVal_int(obj0, &val1);
23538 if (!SWIG_IsOK(ecode1)) {
23539 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23540 }
23541 arg1 = static_cast< int >(val1);
23542 }
23543 if (obj1) {
23544 ecode2 = SWIG_AsVal_int(obj1, &val2);
23545 if (!SWIG_IsOK(ecode2)) {
23546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23547 }
23548 arg2 = static_cast< wxDateTime::Calendar >(val2);
23549 }
23550 {
23551 PyThreadState* __tstate = wxPyBeginAllowThreads();
23552 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23553 wxPyEndAllowThreads(__tstate);
23554 if (PyErr_Occurred()) SWIG_fail;
23555 }
23556 {
23557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23558 }
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23566 PyObject *resultobj = 0;
23567 int arg1 = (int) wxDateTime::Inv_Year ;
23568 int result;
23569 int val1 ;
23570 int ecode1 = 0 ;
23571 PyObject * obj0 = 0 ;
23572 char * kwnames[] = {
23573 (char *) "year", NULL
23574 };
23575
23576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23577 if (obj0) {
23578 ecode1 = SWIG_AsVal_int(obj0, &val1);
23579 if (!SWIG_IsOK(ecode1)) {
23580 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23581 }
23582 arg1 = static_cast< int >(val1);
23583 }
23584 {
23585 PyThreadState* __tstate = wxPyBeginAllowThreads();
23586 result = (int)wxDateTime::GetCentury(arg1);
23587 wxPyEndAllowThreads(__tstate);
23588 if (PyErr_Occurred()) SWIG_fail;
23589 }
23590 resultobj = SWIG_From_int(static_cast< int >(result));
23591 return resultobj;
23592 fail:
23593 return NULL;
23594 }
23595
23596
23597 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23598 PyObject *resultobj = 0;
23599 int arg1 ;
23600 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23601 int result;
23602 int val1 ;
23603 int ecode1 = 0 ;
23604 int val2 ;
23605 int ecode2 = 0 ;
23606 PyObject * obj0 = 0 ;
23607 PyObject * obj1 = 0 ;
23608 char * kwnames[] = {
23609 (char *) "year",(char *) "cal", NULL
23610 };
23611
23612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23613 ecode1 = SWIG_AsVal_int(obj0, &val1);
23614 if (!SWIG_IsOK(ecode1)) {
23615 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23616 }
23617 arg1 = static_cast< int >(val1);
23618 if (obj1) {
23619 ecode2 = SWIG_AsVal_int(obj1, &val2);
23620 if (!SWIG_IsOK(ecode2)) {
23621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23622 }
23623 arg2 = static_cast< wxDateTime::Calendar >(val2);
23624 }
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23628 wxPyEndAllowThreads(__tstate);
23629 if (PyErr_Occurred()) SWIG_fail;
23630 }
23631 resultobj = SWIG_From_int(static_cast< int >(result));
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj = 0;
23640 wxDateTime::Month arg1 ;
23641 int arg2 = (int) wxDateTime::Inv_Year ;
23642 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23643 int result;
23644 int val1 ;
23645 int ecode1 = 0 ;
23646 int val2 ;
23647 int ecode2 = 0 ;
23648 int val3 ;
23649 int ecode3 = 0 ;
23650 PyObject * obj0 = 0 ;
23651 PyObject * obj1 = 0 ;
23652 PyObject * obj2 = 0 ;
23653 char * kwnames[] = {
23654 (char *) "month",(char *) "year",(char *) "cal", NULL
23655 };
23656
23657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23658 ecode1 = SWIG_AsVal_int(obj0, &val1);
23659 if (!SWIG_IsOK(ecode1)) {
23660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23661 }
23662 arg1 = static_cast< wxDateTime::Month >(val1);
23663 if (obj1) {
23664 ecode2 = SWIG_AsVal_int(obj1, &val2);
23665 if (!SWIG_IsOK(ecode2)) {
23666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23667 }
23668 arg2 = static_cast< int >(val2);
23669 }
23670 if (obj2) {
23671 ecode3 = SWIG_AsVal_int(obj2, &val3);
23672 if (!SWIG_IsOK(ecode3)) {
23673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23674 }
23675 arg3 = static_cast< wxDateTime::Calendar >(val3);
23676 }
23677 {
23678 PyThreadState* __tstate = wxPyBeginAllowThreads();
23679 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23680 wxPyEndAllowThreads(__tstate);
23681 if (PyErr_Occurred()) SWIG_fail;
23682 }
23683 resultobj = SWIG_From_int(static_cast< int >(result));
23684 return resultobj;
23685 fail:
23686 return NULL;
23687 }
23688
23689
23690 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23691 PyObject *resultobj = 0;
23692 wxDateTime::Month arg1 ;
23693 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23694 wxString result;
23695 int val1 ;
23696 int ecode1 = 0 ;
23697 int val2 ;
23698 int ecode2 = 0 ;
23699 PyObject * obj0 = 0 ;
23700 PyObject * obj1 = 0 ;
23701 char * kwnames[] = {
23702 (char *) "month",(char *) "flags", NULL
23703 };
23704
23705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23706 ecode1 = SWIG_AsVal_int(obj0, &val1);
23707 if (!SWIG_IsOK(ecode1)) {
23708 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23709 }
23710 arg1 = static_cast< wxDateTime::Month >(val1);
23711 if (obj1) {
23712 ecode2 = SWIG_AsVal_int(obj1, &val2);
23713 if (!SWIG_IsOK(ecode2)) {
23714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23715 }
23716 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23717 }
23718 {
23719 PyThreadState* __tstate = wxPyBeginAllowThreads();
23720 result = wxDateTime::GetMonthName(arg1,arg2);
23721 wxPyEndAllowThreads(__tstate);
23722 if (PyErr_Occurred()) SWIG_fail;
23723 }
23724 {
23725 #if wxUSE_UNICODE
23726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23727 #else
23728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23729 #endif
23730 }
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23738 PyObject *resultobj = 0;
23739 wxDateTime::WeekDay arg1 ;
23740 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23741 wxString result;
23742 int val1 ;
23743 int ecode1 = 0 ;
23744 int val2 ;
23745 int ecode2 = 0 ;
23746 PyObject * obj0 = 0 ;
23747 PyObject * obj1 = 0 ;
23748 char * kwnames[] = {
23749 (char *) "weekday",(char *) "flags", NULL
23750 };
23751
23752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23753 ecode1 = SWIG_AsVal_int(obj0, &val1);
23754 if (!SWIG_IsOK(ecode1)) {
23755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23756 }
23757 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23758 if (obj1) {
23759 ecode2 = SWIG_AsVal_int(obj1, &val2);
23760 if (!SWIG_IsOK(ecode2)) {
23761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23762 }
23763 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23764 }
23765 {
23766 PyThreadState* __tstate = wxPyBeginAllowThreads();
23767 result = wxDateTime::GetWeekDayName(arg1,arg2);
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 {
23772 #if wxUSE_UNICODE
23773 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23774 #else
23775 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23776 #endif
23777 }
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23785 PyObject *resultobj = 0;
23786 PyObject *result = 0 ;
23787
23788 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23789 {
23790 PyThreadState* __tstate = wxPyBeginAllowThreads();
23791 result = (PyObject *)wxDateTime_GetAmPmStrings();
23792 wxPyEndAllowThreads(__tstate);
23793 if (PyErr_Occurred()) SWIG_fail;
23794 }
23795 resultobj = result;
23796 return resultobj;
23797 fail:
23798 return NULL;
23799 }
23800
23801
23802 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23803 PyObject *resultobj = 0;
23804 int arg1 = (int) wxDateTime::Inv_Year ;
23805 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23806 bool result;
23807 int val1 ;
23808 int ecode1 = 0 ;
23809 int val2 ;
23810 int ecode2 = 0 ;
23811 PyObject * obj0 = 0 ;
23812 PyObject * obj1 = 0 ;
23813 char * kwnames[] = {
23814 (char *) "year",(char *) "country", NULL
23815 };
23816
23817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23818 if (obj0) {
23819 ecode1 = SWIG_AsVal_int(obj0, &val1);
23820 if (!SWIG_IsOK(ecode1)) {
23821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23822 }
23823 arg1 = static_cast< int >(val1);
23824 }
23825 if (obj1) {
23826 ecode2 = SWIG_AsVal_int(obj1, &val2);
23827 if (!SWIG_IsOK(ecode2)) {
23828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23829 }
23830 arg2 = static_cast< wxDateTime::Country >(val2);
23831 }
23832 {
23833 PyThreadState* __tstate = wxPyBeginAllowThreads();
23834 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23835 wxPyEndAllowThreads(__tstate);
23836 if (PyErr_Occurred()) SWIG_fail;
23837 }
23838 {
23839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23840 }
23841 return resultobj;
23842 fail:
23843 return NULL;
23844 }
23845
23846
23847 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23848 PyObject *resultobj = 0;
23849 int arg1 = (int) wxDateTime::Inv_Year ;
23850 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23851 wxDateTime result;
23852 int val1 ;
23853 int ecode1 = 0 ;
23854 int val2 ;
23855 int ecode2 = 0 ;
23856 PyObject * obj0 = 0 ;
23857 PyObject * obj1 = 0 ;
23858 char * kwnames[] = {
23859 (char *) "year",(char *) "country", NULL
23860 };
23861
23862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23863 if (obj0) {
23864 ecode1 = SWIG_AsVal_int(obj0, &val1);
23865 if (!SWIG_IsOK(ecode1)) {
23866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23867 }
23868 arg1 = static_cast< int >(val1);
23869 }
23870 if (obj1) {
23871 ecode2 = SWIG_AsVal_int(obj1, &val2);
23872 if (!SWIG_IsOK(ecode2)) {
23873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23874 }
23875 arg2 = static_cast< wxDateTime::Country >(val2);
23876 }
23877 {
23878 PyThreadState* __tstate = wxPyBeginAllowThreads();
23879 result = wxDateTime::GetBeginDST(arg1,arg2);
23880 wxPyEndAllowThreads(__tstate);
23881 if (PyErr_Occurred()) SWIG_fail;
23882 }
23883 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23884 return resultobj;
23885 fail:
23886 return NULL;
23887 }
23888
23889
23890 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23891 PyObject *resultobj = 0;
23892 int arg1 = (int) wxDateTime::Inv_Year ;
23893 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23894 wxDateTime result;
23895 int val1 ;
23896 int ecode1 = 0 ;
23897 int val2 ;
23898 int ecode2 = 0 ;
23899 PyObject * obj0 = 0 ;
23900 PyObject * obj1 = 0 ;
23901 char * kwnames[] = {
23902 (char *) "year",(char *) "country", NULL
23903 };
23904
23905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23906 if (obj0) {
23907 ecode1 = SWIG_AsVal_int(obj0, &val1);
23908 if (!SWIG_IsOK(ecode1)) {
23909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23910 }
23911 arg1 = static_cast< int >(val1);
23912 }
23913 if (obj1) {
23914 ecode2 = SWIG_AsVal_int(obj1, &val2);
23915 if (!SWIG_IsOK(ecode2)) {
23916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23917 }
23918 arg2 = static_cast< wxDateTime::Country >(val2);
23919 }
23920 {
23921 PyThreadState* __tstate = wxPyBeginAllowThreads();
23922 result = wxDateTime::GetEndDST(arg1,arg2);
23923 wxPyEndAllowThreads(__tstate);
23924 if (PyErr_Occurred()) SWIG_fail;
23925 }
23926 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23927 return resultobj;
23928 fail:
23929 return NULL;
23930 }
23931
23932
23933 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23934 PyObject *resultobj = 0;
23935 wxDateTime result;
23936
23937 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 result = wxDateTime::Now();
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23952 PyObject *resultobj = 0;
23953 wxDateTime result;
23954
23955 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23956 {
23957 PyThreadState* __tstate = wxPyBeginAllowThreads();
23958 result = wxDateTime::UNow();
23959 wxPyEndAllowThreads(__tstate);
23960 if (PyErr_Occurred()) SWIG_fail;
23961 }
23962 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23963 return resultobj;
23964 fail:
23965 return NULL;
23966 }
23967
23968
23969 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23970 PyObject *resultobj = 0;
23971 wxDateTime result;
23972
23973 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23974 {
23975 PyThreadState* __tstate = wxPyBeginAllowThreads();
23976 result = wxDateTime::Today();
23977 wxPyEndAllowThreads(__tstate);
23978 if (PyErr_Occurred()) SWIG_fail;
23979 }
23980 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23981 return resultobj;
23982 fail:
23983 return NULL;
23984 }
23985
23986
23987 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23988 PyObject *resultobj = 0;
23989 wxDateTime *result = 0 ;
23990
23991 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 result = (wxDateTime *)new wxDateTime();
23995 wxPyEndAllowThreads(__tstate);
23996 if (PyErr_Occurred()) SWIG_fail;
23997 }
23998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24006 PyObject *resultobj = 0;
24007 time_t arg1 ;
24008 wxDateTime *result = 0 ;
24009 unsigned int val1 ;
24010 int ecode1 = 0 ;
24011 PyObject * obj0 = 0 ;
24012 char * kwnames[] = {
24013 (char *) "timet", NULL
24014 };
24015
24016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
24017 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
24018 if (!SWIG_IsOK(ecode1)) {
24019 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
24020 }
24021 arg1 = static_cast< time_t >(val1);
24022 {
24023 PyThreadState* __tstate = wxPyBeginAllowThreads();
24024 result = (wxDateTime *)new wxDateTime(arg1);
24025 wxPyEndAllowThreads(__tstate);
24026 if (PyErr_Occurred()) SWIG_fail;
24027 }
24028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24029 return resultobj;
24030 fail:
24031 return NULL;
24032 }
24033
24034
24035 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24036 PyObject *resultobj = 0;
24037 double arg1 ;
24038 wxDateTime *result = 0 ;
24039 double val1 ;
24040 int ecode1 = 0 ;
24041 PyObject * obj0 = 0 ;
24042 char * kwnames[] = {
24043 (char *) "jdn", NULL
24044 };
24045
24046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
24047 ecode1 = SWIG_AsVal_double(obj0, &val1);
24048 if (!SWIG_IsOK(ecode1)) {
24049 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
24050 }
24051 arg1 = static_cast< double >(val1);
24052 {
24053 PyThreadState* __tstate = wxPyBeginAllowThreads();
24054 result = (wxDateTime *)new wxDateTime(arg1);
24055 wxPyEndAllowThreads(__tstate);
24056 if (PyErr_Occurred()) SWIG_fail;
24057 }
24058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24066 PyObject *resultobj = 0;
24067 int arg1 ;
24068 int arg2 = (int) 0 ;
24069 int arg3 = (int) 0 ;
24070 int arg4 = (int) 0 ;
24071 wxDateTime *result = 0 ;
24072 int val1 ;
24073 int ecode1 = 0 ;
24074 int val2 ;
24075 int ecode2 = 0 ;
24076 int val3 ;
24077 int ecode3 = 0 ;
24078 int val4 ;
24079 int ecode4 = 0 ;
24080 PyObject * obj0 = 0 ;
24081 PyObject * obj1 = 0 ;
24082 PyObject * obj2 = 0 ;
24083 PyObject * obj3 = 0 ;
24084 char * kwnames[] = {
24085 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24086 };
24087
24088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24089 ecode1 = SWIG_AsVal_int(obj0, &val1);
24090 if (!SWIG_IsOK(ecode1)) {
24091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
24092 }
24093 arg1 = static_cast< int >(val1);
24094 if (obj1) {
24095 ecode2 = SWIG_AsVal_int(obj1, &val2);
24096 if (!SWIG_IsOK(ecode2)) {
24097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
24098 }
24099 arg2 = static_cast< int >(val2);
24100 }
24101 if (obj2) {
24102 ecode3 = SWIG_AsVal_int(obj2, &val3);
24103 if (!SWIG_IsOK(ecode3)) {
24104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
24105 }
24106 arg3 = static_cast< int >(val3);
24107 }
24108 if (obj3) {
24109 ecode4 = SWIG_AsVal_int(obj3, &val4);
24110 if (!SWIG_IsOK(ecode4)) {
24111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
24112 }
24113 arg4 = static_cast< int >(val4);
24114 }
24115 {
24116 PyThreadState* __tstate = wxPyBeginAllowThreads();
24117 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
24118 wxPyEndAllowThreads(__tstate);
24119 if (PyErr_Occurred()) SWIG_fail;
24120 }
24121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24122 return resultobj;
24123 fail:
24124 return NULL;
24125 }
24126
24127
24128 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24129 PyObject *resultobj = 0;
24130 int arg1 ;
24131 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24132 int arg3 = (int) wxDateTime::Inv_Year ;
24133 int arg4 = (int) 0 ;
24134 int arg5 = (int) 0 ;
24135 int arg6 = (int) 0 ;
24136 int arg7 = (int) 0 ;
24137 wxDateTime *result = 0 ;
24138 int val1 ;
24139 int ecode1 = 0 ;
24140 int val2 ;
24141 int ecode2 = 0 ;
24142 int val3 ;
24143 int ecode3 = 0 ;
24144 int val4 ;
24145 int ecode4 = 0 ;
24146 int val5 ;
24147 int ecode5 = 0 ;
24148 int val6 ;
24149 int ecode6 = 0 ;
24150 int val7 ;
24151 int ecode7 = 0 ;
24152 PyObject * obj0 = 0 ;
24153 PyObject * obj1 = 0 ;
24154 PyObject * obj2 = 0 ;
24155 PyObject * obj3 = 0 ;
24156 PyObject * obj4 = 0 ;
24157 PyObject * obj5 = 0 ;
24158 PyObject * obj6 = 0 ;
24159 char * kwnames[] = {
24160 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24161 };
24162
24163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24164 ecode1 = SWIG_AsVal_int(obj0, &val1);
24165 if (!SWIG_IsOK(ecode1)) {
24166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24167 }
24168 arg1 = static_cast< int >(val1);
24169 if (obj1) {
24170 ecode2 = SWIG_AsVal_int(obj1, &val2);
24171 if (!SWIG_IsOK(ecode2)) {
24172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24173 }
24174 arg2 = static_cast< wxDateTime::Month >(val2);
24175 }
24176 if (obj2) {
24177 ecode3 = SWIG_AsVal_int(obj2, &val3);
24178 if (!SWIG_IsOK(ecode3)) {
24179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24180 }
24181 arg3 = static_cast< int >(val3);
24182 }
24183 if (obj3) {
24184 ecode4 = SWIG_AsVal_int(obj3, &val4);
24185 if (!SWIG_IsOK(ecode4)) {
24186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24187 }
24188 arg4 = static_cast< int >(val4);
24189 }
24190 if (obj4) {
24191 ecode5 = SWIG_AsVal_int(obj4, &val5);
24192 if (!SWIG_IsOK(ecode5)) {
24193 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24194 }
24195 arg5 = static_cast< int >(val5);
24196 }
24197 if (obj5) {
24198 ecode6 = SWIG_AsVal_int(obj5, &val6);
24199 if (!SWIG_IsOK(ecode6)) {
24200 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24201 }
24202 arg6 = static_cast< int >(val6);
24203 }
24204 if (obj6) {
24205 ecode7 = SWIG_AsVal_int(obj6, &val7);
24206 if (!SWIG_IsOK(ecode7)) {
24207 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24208 }
24209 arg7 = static_cast< int >(val7);
24210 }
24211 {
24212 PyThreadState* __tstate = wxPyBeginAllowThreads();
24213 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24214 wxPyEndAllowThreads(__tstate);
24215 if (PyErr_Occurred()) SWIG_fail;
24216 }
24217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj = 0;
24226 wxDateTime *arg1 = 0 ;
24227 wxDateTime *result = 0 ;
24228 void *argp1 = 0 ;
24229 int res1 = 0 ;
24230 PyObject * obj0 = 0 ;
24231 char * kwnames[] = {
24232 (char *) "date", NULL
24233 };
24234
24235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24236 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24237 if (!SWIG_IsOK(res1)) {
24238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24239 }
24240 if (!argp1) {
24241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24242 }
24243 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24244 {
24245 PyThreadState* __tstate = wxPyBeginAllowThreads();
24246 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24247 wxPyEndAllowThreads(__tstate);
24248 if (PyErr_Occurred()) SWIG_fail;
24249 }
24250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24251 return resultobj;
24252 fail:
24253 return NULL;
24254 }
24255
24256
24257 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24258 PyObject *resultobj = 0;
24259 wxDateTime *arg1 = (wxDateTime *) 0 ;
24260 void *argp1 = 0 ;
24261 int res1 = 0 ;
24262 PyObject *swig_obj[1] ;
24263
24264 if (!args) SWIG_fail;
24265 swig_obj[0] = args;
24266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24267 if (!SWIG_IsOK(res1)) {
24268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24269 }
24270 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24271 {
24272 PyThreadState* __tstate = wxPyBeginAllowThreads();
24273 delete arg1;
24274
24275 wxPyEndAllowThreads(__tstate);
24276 if (PyErr_Occurred()) SWIG_fail;
24277 }
24278 resultobj = SWIG_Py_Void();
24279 return resultobj;
24280 fail:
24281 return NULL;
24282 }
24283
24284
24285 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24286 PyObject *resultobj = 0;
24287 wxDateTime *arg1 = (wxDateTime *) 0 ;
24288 wxDateTime *result = 0 ;
24289 void *argp1 = 0 ;
24290 int res1 = 0 ;
24291 PyObject *swig_obj[1] ;
24292
24293 if (!args) SWIG_fail;
24294 swig_obj[0] = args;
24295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24296 if (!SWIG_IsOK(res1)) {
24297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24298 }
24299 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24300 {
24301 PyThreadState* __tstate = wxPyBeginAllowThreads();
24302 {
24303 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24304 result = (wxDateTime *) &_result_ref;
24305 }
24306 wxPyEndAllowThreads(__tstate);
24307 if (PyErr_Occurred()) SWIG_fail;
24308 }
24309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24310 return resultobj;
24311 fail:
24312 return NULL;
24313 }
24314
24315
24316 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24317 PyObject *resultobj = 0;
24318 wxDateTime *arg1 = (wxDateTime *) 0 ;
24319 time_t arg2 ;
24320 wxDateTime *result = 0 ;
24321 void *argp1 = 0 ;
24322 int res1 = 0 ;
24323 unsigned int val2 ;
24324 int ecode2 = 0 ;
24325 PyObject * obj0 = 0 ;
24326 PyObject * obj1 = 0 ;
24327 char * kwnames[] = {
24328 (char *) "self",(char *) "timet", NULL
24329 };
24330
24331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24333 if (!SWIG_IsOK(res1)) {
24334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24335 }
24336 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24337 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24338 if (!SWIG_IsOK(ecode2)) {
24339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24340 }
24341 arg2 = static_cast< time_t >(val2);
24342 {
24343 PyThreadState* __tstate = wxPyBeginAllowThreads();
24344 {
24345 wxDateTime &_result_ref = (arg1)->Set(arg2);
24346 result = (wxDateTime *) &_result_ref;
24347 }
24348 wxPyEndAllowThreads(__tstate);
24349 if (PyErr_Occurred()) SWIG_fail;
24350 }
24351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24359 PyObject *resultobj = 0;
24360 wxDateTime *arg1 = (wxDateTime *) 0 ;
24361 double arg2 ;
24362 wxDateTime *result = 0 ;
24363 void *argp1 = 0 ;
24364 int res1 = 0 ;
24365 double val2 ;
24366 int ecode2 = 0 ;
24367 PyObject * obj0 = 0 ;
24368 PyObject * obj1 = 0 ;
24369 char * kwnames[] = {
24370 (char *) "self",(char *) "jdn", NULL
24371 };
24372
24373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24375 if (!SWIG_IsOK(res1)) {
24376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24377 }
24378 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24379 ecode2 = SWIG_AsVal_double(obj1, &val2);
24380 if (!SWIG_IsOK(ecode2)) {
24381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24382 }
24383 arg2 = static_cast< double >(val2);
24384 {
24385 PyThreadState* __tstate = wxPyBeginAllowThreads();
24386 {
24387 wxDateTime &_result_ref = (arg1)->Set(arg2);
24388 result = (wxDateTime *) &_result_ref;
24389 }
24390 wxPyEndAllowThreads(__tstate);
24391 if (PyErr_Occurred()) SWIG_fail;
24392 }
24393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24394 return resultobj;
24395 fail:
24396 return NULL;
24397 }
24398
24399
24400 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24401 PyObject *resultobj = 0;
24402 wxDateTime *arg1 = (wxDateTime *) 0 ;
24403 int arg2 ;
24404 int arg3 = (int) 0 ;
24405 int arg4 = (int) 0 ;
24406 int arg5 = (int) 0 ;
24407 wxDateTime *result = 0 ;
24408 void *argp1 = 0 ;
24409 int res1 = 0 ;
24410 int val2 ;
24411 int ecode2 = 0 ;
24412 int val3 ;
24413 int ecode3 = 0 ;
24414 int val4 ;
24415 int ecode4 = 0 ;
24416 int val5 ;
24417 int ecode5 = 0 ;
24418 PyObject * obj0 = 0 ;
24419 PyObject * obj1 = 0 ;
24420 PyObject * obj2 = 0 ;
24421 PyObject * obj3 = 0 ;
24422 PyObject * obj4 = 0 ;
24423 char * kwnames[] = {
24424 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24425 };
24426
24427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24429 if (!SWIG_IsOK(res1)) {
24430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24431 }
24432 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24433 ecode2 = SWIG_AsVal_int(obj1, &val2);
24434 if (!SWIG_IsOK(ecode2)) {
24435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24436 }
24437 arg2 = static_cast< int >(val2);
24438 if (obj2) {
24439 ecode3 = SWIG_AsVal_int(obj2, &val3);
24440 if (!SWIG_IsOK(ecode3)) {
24441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24442 }
24443 arg3 = static_cast< int >(val3);
24444 }
24445 if (obj3) {
24446 ecode4 = SWIG_AsVal_int(obj3, &val4);
24447 if (!SWIG_IsOK(ecode4)) {
24448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24449 }
24450 arg4 = static_cast< int >(val4);
24451 }
24452 if (obj4) {
24453 ecode5 = SWIG_AsVal_int(obj4, &val5);
24454 if (!SWIG_IsOK(ecode5)) {
24455 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24456 }
24457 arg5 = static_cast< int >(val5);
24458 }
24459 {
24460 PyThreadState* __tstate = wxPyBeginAllowThreads();
24461 {
24462 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24463 result = (wxDateTime *) &_result_ref;
24464 }
24465 wxPyEndAllowThreads(__tstate);
24466 if (PyErr_Occurred()) SWIG_fail;
24467 }
24468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24469 return resultobj;
24470 fail:
24471 return NULL;
24472 }
24473
24474
24475 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24476 PyObject *resultobj = 0;
24477 wxDateTime *arg1 = (wxDateTime *) 0 ;
24478 int arg2 ;
24479 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24480 int arg4 = (int) wxDateTime::Inv_Year ;
24481 int arg5 = (int) 0 ;
24482 int arg6 = (int) 0 ;
24483 int arg7 = (int) 0 ;
24484 int arg8 = (int) 0 ;
24485 wxDateTime *result = 0 ;
24486 void *argp1 = 0 ;
24487 int res1 = 0 ;
24488 int val2 ;
24489 int ecode2 = 0 ;
24490 int val3 ;
24491 int ecode3 = 0 ;
24492 int val4 ;
24493 int ecode4 = 0 ;
24494 int val5 ;
24495 int ecode5 = 0 ;
24496 int val6 ;
24497 int ecode6 = 0 ;
24498 int val7 ;
24499 int ecode7 = 0 ;
24500 int val8 ;
24501 int ecode8 = 0 ;
24502 PyObject * obj0 = 0 ;
24503 PyObject * obj1 = 0 ;
24504 PyObject * obj2 = 0 ;
24505 PyObject * obj3 = 0 ;
24506 PyObject * obj4 = 0 ;
24507 PyObject * obj5 = 0 ;
24508 PyObject * obj6 = 0 ;
24509 PyObject * obj7 = 0 ;
24510 char * kwnames[] = {
24511 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24512 };
24513
24514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24516 if (!SWIG_IsOK(res1)) {
24517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24518 }
24519 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24520 ecode2 = SWIG_AsVal_int(obj1, &val2);
24521 if (!SWIG_IsOK(ecode2)) {
24522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24523 }
24524 arg2 = static_cast< int >(val2);
24525 if (obj2) {
24526 ecode3 = SWIG_AsVal_int(obj2, &val3);
24527 if (!SWIG_IsOK(ecode3)) {
24528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24529 }
24530 arg3 = static_cast< wxDateTime::Month >(val3);
24531 }
24532 if (obj3) {
24533 ecode4 = SWIG_AsVal_int(obj3, &val4);
24534 if (!SWIG_IsOK(ecode4)) {
24535 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24536 }
24537 arg4 = static_cast< int >(val4);
24538 }
24539 if (obj4) {
24540 ecode5 = SWIG_AsVal_int(obj4, &val5);
24541 if (!SWIG_IsOK(ecode5)) {
24542 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24543 }
24544 arg5 = static_cast< int >(val5);
24545 }
24546 if (obj5) {
24547 ecode6 = SWIG_AsVal_int(obj5, &val6);
24548 if (!SWIG_IsOK(ecode6)) {
24549 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24550 }
24551 arg6 = static_cast< int >(val6);
24552 }
24553 if (obj6) {
24554 ecode7 = SWIG_AsVal_int(obj6, &val7);
24555 if (!SWIG_IsOK(ecode7)) {
24556 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24557 }
24558 arg7 = static_cast< int >(val7);
24559 }
24560 if (obj7) {
24561 ecode8 = SWIG_AsVal_int(obj7, &val8);
24562 if (!SWIG_IsOK(ecode8)) {
24563 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24564 }
24565 arg8 = static_cast< int >(val8);
24566 }
24567 {
24568 PyThreadState* __tstate = wxPyBeginAllowThreads();
24569 {
24570 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24571 result = (wxDateTime *) &_result_ref;
24572 }
24573 wxPyEndAllowThreads(__tstate);
24574 if (PyErr_Occurred()) SWIG_fail;
24575 }
24576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24577 return resultobj;
24578 fail:
24579 return NULL;
24580 }
24581
24582
24583 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24584 PyObject *resultobj = 0;
24585 wxDateTime *arg1 = (wxDateTime *) 0 ;
24586 wxDateTime *result = 0 ;
24587 void *argp1 = 0 ;
24588 int res1 = 0 ;
24589 PyObject *swig_obj[1] ;
24590
24591 if (!args) SWIG_fail;
24592 swig_obj[0] = args;
24593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24594 if (!SWIG_IsOK(res1)) {
24595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24596 }
24597 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24598 {
24599 PyThreadState* __tstate = wxPyBeginAllowThreads();
24600 {
24601 wxDateTime &_result_ref = (arg1)->ResetTime();
24602 result = (wxDateTime *) &_result_ref;
24603 }
24604 wxPyEndAllowThreads(__tstate);
24605 if (PyErr_Occurred()) SWIG_fail;
24606 }
24607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24608 return resultobj;
24609 fail:
24610 return NULL;
24611 }
24612
24613
24614 SWIGINTERN PyObject *_wrap_DateTime_GetDateOnly(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24615 PyObject *resultobj = 0;
24616 wxDateTime *arg1 = (wxDateTime *) 0 ;
24617 wxDateTime result;
24618 void *argp1 = 0 ;
24619 int res1 = 0 ;
24620 PyObject *swig_obj[1] ;
24621
24622 if (!args) SWIG_fail;
24623 swig_obj[0] = args;
24624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24625 if (!SWIG_IsOK(res1)) {
24626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDateOnly" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24627 }
24628 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24629 {
24630 PyThreadState* __tstate = wxPyBeginAllowThreads();
24631 result = ((wxDateTime const *)arg1)->GetDateOnly();
24632 wxPyEndAllowThreads(__tstate);
24633 if (PyErr_Occurred()) SWIG_fail;
24634 }
24635 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24636 return resultobj;
24637 fail:
24638 return NULL;
24639 }
24640
24641
24642 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24643 PyObject *resultobj = 0;
24644 wxDateTime *arg1 = (wxDateTime *) 0 ;
24645 int arg2 ;
24646 wxDateTime *result = 0 ;
24647 void *argp1 = 0 ;
24648 int res1 = 0 ;
24649 int val2 ;
24650 int ecode2 = 0 ;
24651 PyObject * obj0 = 0 ;
24652 PyObject * obj1 = 0 ;
24653 char * kwnames[] = {
24654 (char *) "self",(char *) "year", NULL
24655 };
24656
24657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24659 if (!SWIG_IsOK(res1)) {
24660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24661 }
24662 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24663 ecode2 = SWIG_AsVal_int(obj1, &val2);
24664 if (!SWIG_IsOK(ecode2)) {
24665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24666 }
24667 arg2 = static_cast< int >(val2);
24668 {
24669 PyThreadState* __tstate = wxPyBeginAllowThreads();
24670 {
24671 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24672 result = (wxDateTime *) &_result_ref;
24673 }
24674 wxPyEndAllowThreads(__tstate);
24675 if (PyErr_Occurred()) SWIG_fail;
24676 }
24677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24678 return resultobj;
24679 fail:
24680 return NULL;
24681 }
24682
24683
24684 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24685 PyObject *resultobj = 0;
24686 wxDateTime *arg1 = (wxDateTime *) 0 ;
24687 wxDateTime::Month arg2 ;
24688 wxDateTime *result = 0 ;
24689 void *argp1 = 0 ;
24690 int res1 = 0 ;
24691 int val2 ;
24692 int ecode2 = 0 ;
24693 PyObject * obj0 = 0 ;
24694 PyObject * obj1 = 0 ;
24695 char * kwnames[] = {
24696 (char *) "self",(char *) "month", NULL
24697 };
24698
24699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24701 if (!SWIG_IsOK(res1)) {
24702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24703 }
24704 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24705 ecode2 = SWIG_AsVal_int(obj1, &val2);
24706 if (!SWIG_IsOK(ecode2)) {
24707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24708 }
24709 arg2 = static_cast< wxDateTime::Month >(val2);
24710 {
24711 PyThreadState* __tstate = wxPyBeginAllowThreads();
24712 {
24713 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24714 result = (wxDateTime *) &_result_ref;
24715 }
24716 wxPyEndAllowThreads(__tstate);
24717 if (PyErr_Occurred()) SWIG_fail;
24718 }
24719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24727 PyObject *resultobj = 0;
24728 wxDateTime *arg1 = (wxDateTime *) 0 ;
24729 int arg2 ;
24730 wxDateTime *result = 0 ;
24731 void *argp1 = 0 ;
24732 int res1 = 0 ;
24733 int val2 ;
24734 int ecode2 = 0 ;
24735 PyObject * obj0 = 0 ;
24736 PyObject * obj1 = 0 ;
24737 char * kwnames[] = {
24738 (char *) "self",(char *) "day", NULL
24739 };
24740
24741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24743 if (!SWIG_IsOK(res1)) {
24744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24745 }
24746 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24747 ecode2 = SWIG_AsVal_int(obj1, &val2);
24748 if (!SWIG_IsOK(ecode2)) {
24749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24750 }
24751 arg2 = static_cast< int >(val2);
24752 {
24753 PyThreadState* __tstate = wxPyBeginAllowThreads();
24754 {
24755 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24756 result = (wxDateTime *) &_result_ref;
24757 }
24758 wxPyEndAllowThreads(__tstate);
24759 if (PyErr_Occurred()) SWIG_fail;
24760 }
24761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24762 return resultobj;
24763 fail:
24764 return NULL;
24765 }
24766
24767
24768 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24769 PyObject *resultobj = 0;
24770 wxDateTime *arg1 = (wxDateTime *) 0 ;
24771 int arg2 ;
24772 wxDateTime *result = 0 ;
24773 void *argp1 = 0 ;
24774 int res1 = 0 ;
24775 int val2 ;
24776 int ecode2 = 0 ;
24777 PyObject * obj0 = 0 ;
24778 PyObject * obj1 = 0 ;
24779 char * kwnames[] = {
24780 (char *) "self",(char *) "hour", NULL
24781 };
24782
24783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24785 if (!SWIG_IsOK(res1)) {
24786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24787 }
24788 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24789 ecode2 = SWIG_AsVal_int(obj1, &val2);
24790 if (!SWIG_IsOK(ecode2)) {
24791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24792 }
24793 arg2 = static_cast< int >(val2);
24794 {
24795 PyThreadState* __tstate = wxPyBeginAllowThreads();
24796 {
24797 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24798 result = (wxDateTime *) &_result_ref;
24799 }
24800 wxPyEndAllowThreads(__tstate);
24801 if (PyErr_Occurred()) SWIG_fail;
24802 }
24803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24804 return resultobj;
24805 fail:
24806 return NULL;
24807 }
24808
24809
24810 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24811 PyObject *resultobj = 0;
24812 wxDateTime *arg1 = (wxDateTime *) 0 ;
24813 int arg2 ;
24814 wxDateTime *result = 0 ;
24815 void *argp1 = 0 ;
24816 int res1 = 0 ;
24817 int val2 ;
24818 int ecode2 = 0 ;
24819 PyObject * obj0 = 0 ;
24820 PyObject * obj1 = 0 ;
24821 char * kwnames[] = {
24822 (char *) "self",(char *) "minute", NULL
24823 };
24824
24825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24827 if (!SWIG_IsOK(res1)) {
24828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24829 }
24830 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24831 ecode2 = SWIG_AsVal_int(obj1, &val2);
24832 if (!SWIG_IsOK(ecode2)) {
24833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24834 }
24835 arg2 = static_cast< int >(val2);
24836 {
24837 PyThreadState* __tstate = wxPyBeginAllowThreads();
24838 {
24839 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24840 result = (wxDateTime *) &_result_ref;
24841 }
24842 wxPyEndAllowThreads(__tstate);
24843 if (PyErr_Occurred()) SWIG_fail;
24844 }
24845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24853 PyObject *resultobj = 0;
24854 wxDateTime *arg1 = (wxDateTime *) 0 ;
24855 int arg2 ;
24856 wxDateTime *result = 0 ;
24857 void *argp1 = 0 ;
24858 int res1 = 0 ;
24859 int val2 ;
24860 int ecode2 = 0 ;
24861 PyObject * obj0 = 0 ;
24862 PyObject * obj1 = 0 ;
24863 char * kwnames[] = {
24864 (char *) "self",(char *) "second", NULL
24865 };
24866
24867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24869 if (!SWIG_IsOK(res1)) {
24870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24871 }
24872 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24873 ecode2 = SWIG_AsVal_int(obj1, &val2);
24874 if (!SWIG_IsOK(ecode2)) {
24875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24876 }
24877 arg2 = static_cast< int >(val2);
24878 {
24879 PyThreadState* __tstate = wxPyBeginAllowThreads();
24880 {
24881 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24882 result = (wxDateTime *) &_result_ref;
24883 }
24884 wxPyEndAllowThreads(__tstate);
24885 if (PyErr_Occurred()) SWIG_fail;
24886 }
24887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24888 return resultobj;
24889 fail:
24890 return NULL;
24891 }
24892
24893
24894 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24895 PyObject *resultobj = 0;
24896 wxDateTime *arg1 = (wxDateTime *) 0 ;
24897 int arg2 ;
24898 wxDateTime *result = 0 ;
24899 void *argp1 = 0 ;
24900 int res1 = 0 ;
24901 int val2 ;
24902 int ecode2 = 0 ;
24903 PyObject * obj0 = 0 ;
24904 PyObject * obj1 = 0 ;
24905 char * kwnames[] = {
24906 (char *) "self",(char *) "millisecond", NULL
24907 };
24908
24909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24911 if (!SWIG_IsOK(res1)) {
24912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24913 }
24914 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24915 ecode2 = SWIG_AsVal_int(obj1, &val2);
24916 if (!SWIG_IsOK(ecode2)) {
24917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24918 }
24919 arg2 = static_cast< int >(val2);
24920 {
24921 PyThreadState* __tstate = wxPyBeginAllowThreads();
24922 {
24923 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24924 result = (wxDateTime *) &_result_ref;
24925 }
24926 wxPyEndAllowThreads(__tstate);
24927 if (PyErr_Occurred()) SWIG_fail;
24928 }
24929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24930 return resultobj;
24931 fail:
24932 return NULL;
24933 }
24934
24935
24936 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24937 PyObject *resultobj = 0;
24938 wxDateTime *arg1 = (wxDateTime *) 0 ;
24939 wxDateTime::WeekDay arg2 ;
24940 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24941 wxDateTime *result = 0 ;
24942 void *argp1 = 0 ;
24943 int res1 = 0 ;
24944 int val2 ;
24945 int ecode2 = 0 ;
24946 int val3 ;
24947 int ecode3 = 0 ;
24948 PyObject * obj0 = 0 ;
24949 PyObject * obj1 = 0 ;
24950 PyObject * obj2 = 0 ;
24951 char * kwnames[] = {
24952 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24953 };
24954
24955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24957 if (!SWIG_IsOK(res1)) {
24958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24959 }
24960 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24961 ecode2 = SWIG_AsVal_int(obj1, &val2);
24962 if (!SWIG_IsOK(ecode2)) {
24963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24964 }
24965 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24966 if (obj2) {
24967 ecode3 = SWIG_AsVal_int(obj2, &val3);
24968 if (!SWIG_IsOK(ecode3)) {
24969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24970 }
24971 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24972 }
24973 {
24974 PyThreadState* __tstate = wxPyBeginAllowThreads();
24975 {
24976 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24977 result = (wxDateTime *) &_result_ref;
24978 }
24979 wxPyEndAllowThreads(__tstate);
24980 if (PyErr_Occurred()) SWIG_fail;
24981 }
24982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24990 PyObject *resultobj = 0;
24991 wxDateTime *arg1 = (wxDateTime *) 0 ;
24992 wxDateTime::WeekDay arg2 ;
24993 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24994 wxDateTime result;
24995 void *argp1 = 0 ;
24996 int res1 = 0 ;
24997 int val2 ;
24998 int ecode2 = 0 ;
24999 int val3 ;
25000 int ecode3 = 0 ;
25001 PyObject * obj0 = 0 ;
25002 PyObject * obj1 = 0 ;
25003 PyObject * obj2 = 0 ;
25004 char * kwnames[] = {
25005 (char *) "self",(char *) "weekday",(char *) "flags", NULL
25006 };
25007
25008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25010 if (!SWIG_IsOK(res1)) {
25011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25012 }
25013 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25014 ecode2 = SWIG_AsVal_int(obj1, &val2);
25015 if (!SWIG_IsOK(ecode2)) {
25016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25017 }
25018 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25019 if (obj2) {
25020 ecode3 = SWIG_AsVal_int(obj2, &val3);
25021 if (!SWIG_IsOK(ecode3)) {
25022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
25023 }
25024 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
25025 }
25026 {
25027 PyThreadState* __tstate = wxPyBeginAllowThreads();
25028 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
25029 wxPyEndAllowThreads(__tstate);
25030 if (PyErr_Occurred()) SWIG_fail;
25031 }
25032 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25033 return resultobj;
25034 fail:
25035 return NULL;
25036 }
25037
25038
25039 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25040 PyObject *resultobj = 0;
25041 wxDateTime *arg1 = (wxDateTime *) 0 ;
25042 wxDateTime::WeekDay arg2 ;
25043 wxDateTime *result = 0 ;
25044 void *argp1 = 0 ;
25045 int res1 = 0 ;
25046 int val2 ;
25047 int ecode2 = 0 ;
25048 PyObject * obj0 = 0 ;
25049 PyObject * obj1 = 0 ;
25050 char * kwnames[] = {
25051 (char *) "self",(char *) "weekday", NULL
25052 };
25053
25054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25056 if (!SWIG_IsOK(res1)) {
25057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25058 }
25059 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25060 ecode2 = SWIG_AsVal_int(obj1, &val2);
25061 if (!SWIG_IsOK(ecode2)) {
25062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25063 }
25064 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25065 {
25066 PyThreadState* __tstate = wxPyBeginAllowThreads();
25067 {
25068 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
25069 result = (wxDateTime *) &_result_ref;
25070 }
25071 wxPyEndAllowThreads(__tstate);
25072 if (PyErr_Occurred()) SWIG_fail;
25073 }
25074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25075 return resultobj;
25076 fail:
25077 return NULL;
25078 }
25079
25080
25081 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25082 PyObject *resultobj = 0;
25083 wxDateTime *arg1 = (wxDateTime *) 0 ;
25084 wxDateTime::WeekDay arg2 ;
25085 wxDateTime result;
25086 void *argp1 = 0 ;
25087 int res1 = 0 ;
25088 int val2 ;
25089 int ecode2 = 0 ;
25090 PyObject * obj0 = 0 ;
25091 PyObject * obj1 = 0 ;
25092 char * kwnames[] = {
25093 (char *) "self",(char *) "weekday", NULL
25094 };
25095
25096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25098 if (!SWIG_IsOK(res1)) {
25099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25100 }
25101 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25102 ecode2 = SWIG_AsVal_int(obj1, &val2);
25103 if (!SWIG_IsOK(ecode2)) {
25104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25105 }
25106 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25107 {
25108 PyThreadState* __tstate = wxPyBeginAllowThreads();
25109 result = (arg1)->GetNextWeekDay(arg2);
25110 wxPyEndAllowThreads(__tstate);
25111 if (PyErr_Occurred()) SWIG_fail;
25112 }
25113 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25114 return resultobj;
25115 fail:
25116 return NULL;
25117 }
25118
25119
25120 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25121 PyObject *resultobj = 0;
25122 wxDateTime *arg1 = (wxDateTime *) 0 ;
25123 wxDateTime::WeekDay arg2 ;
25124 wxDateTime *result = 0 ;
25125 void *argp1 = 0 ;
25126 int res1 = 0 ;
25127 int val2 ;
25128 int ecode2 = 0 ;
25129 PyObject * obj0 = 0 ;
25130 PyObject * obj1 = 0 ;
25131 char * kwnames[] = {
25132 (char *) "self",(char *) "weekday", NULL
25133 };
25134
25135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25137 if (!SWIG_IsOK(res1)) {
25138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25139 }
25140 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25141 ecode2 = SWIG_AsVal_int(obj1, &val2);
25142 if (!SWIG_IsOK(ecode2)) {
25143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25144 }
25145 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25146 {
25147 PyThreadState* __tstate = wxPyBeginAllowThreads();
25148 {
25149 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
25150 result = (wxDateTime *) &_result_ref;
25151 }
25152 wxPyEndAllowThreads(__tstate);
25153 if (PyErr_Occurred()) SWIG_fail;
25154 }
25155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25156 return resultobj;
25157 fail:
25158 return NULL;
25159 }
25160
25161
25162 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25163 PyObject *resultobj = 0;
25164 wxDateTime *arg1 = (wxDateTime *) 0 ;
25165 wxDateTime::WeekDay arg2 ;
25166 wxDateTime result;
25167 void *argp1 = 0 ;
25168 int res1 = 0 ;
25169 int val2 ;
25170 int ecode2 = 0 ;
25171 PyObject * obj0 = 0 ;
25172 PyObject * obj1 = 0 ;
25173 char * kwnames[] = {
25174 (char *) "self",(char *) "weekday", NULL
25175 };
25176
25177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25179 if (!SWIG_IsOK(res1)) {
25180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25181 }
25182 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25183 ecode2 = SWIG_AsVal_int(obj1, &val2);
25184 if (!SWIG_IsOK(ecode2)) {
25185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25186 }
25187 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25188 {
25189 PyThreadState* __tstate = wxPyBeginAllowThreads();
25190 result = (arg1)->GetPrevWeekDay(arg2);
25191 wxPyEndAllowThreads(__tstate);
25192 if (PyErr_Occurred()) SWIG_fail;
25193 }
25194 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25195 return resultobj;
25196 fail:
25197 return NULL;
25198 }
25199
25200
25201 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25202 PyObject *resultobj = 0;
25203 wxDateTime *arg1 = (wxDateTime *) 0 ;
25204 wxDateTime::WeekDay arg2 ;
25205 int arg3 = (int) 1 ;
25206 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25207 int arg5 = (int) wxDateTime::Inv_Year ;
25208 bool result;
25209 void *argp1 = 0 ;
25210 int res1 = 0 ;
25211 int val2 ;
25212 int ecode2 = 0 ;
25213 int val3 ;
25214 int ecode3 = 0 ;
25215 int val4 ;
25216 int ecode4 = 0 ;
25217 int val5 ;
25218 int ecode5 = 0 ;
25219 PyObject * obj0 = 0 ;
25220 PyObject * obj1 = 0 ;
25221 PyObject * obj2 = 0 ;
25222 PyObject * obj3 = 0 ;
25223 PyObject * obj4 = 0 ;
25224 char * kwnames[] = {
25225 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25226 };
25227
25228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25230 if (!SWIG_IsOK(res1)) {
25231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25232 }
25233 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25234 ecode2 = SWIG_AsVal_int(obj1, &val2);
25235 if (!SWIG_IsOK(ecode2)) {
25236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25237 }
25238 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25239 if (obj2) {
25240 ecode3 = SWIG_AsVal_int(obj2, &val3);
25241 if (!SWIG_IsOK(ecode3)) {
25242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25243 }
25244 arg3 = static_cast< int >(val3);
25245 }
25246 if (obj3) {
25247 ecode4 = SWIG_AsVal_int(obj3, &val4);
25248 if (!SWIG_IsOK(ecode4)) {
25249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25250 }
25251 arg4 = static_cast< wxDateTime::Month >(val4);
25252 }
25253 if (obj4) {
25254 ecode5 = SWIG_AsVal_int(obj4, &val5);
25255 if (!SWIG_IsOK(ecode5)) {
25256 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25257 }
25258 arg5 = static_cast< int >(val5);
25259 }
25260 {
25261 PyThreadState* __tstate = wxPyBeginAllowThreads();
25262 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25263 wxPyEndAllowThreads(__tstate);
25264 if (PyErr_Occurred()) SWIG_fail;
25265 }
25266 {
25267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25268 }
25269 return resultobj;
25270 fail:
25271 return NULL;
25272 }
25273
25274
25275 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25276 PyObject *resultobj = 0;
25277 wxDateTime *arg1 = (wxDateTime *) 0 ;
25278 wxDateTime::WeekDay arg2 ;
25279 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25280 int arg4 = (int) wxDateTime::Inv_Year ;
25281 bool result;
25282 void *argp1 = 0 ;
25283 int res1 = 0 ;
25284 int val2 ;
25285 int ecode2 = 0 ;
25286 int val3 ;
25287 int ecode3 = 0 ;
25288 int val4 ;
25289 int ecode4 = 0 ;
25290 PyObject * obj0 = 0 ;
25291 PyObject * obj1 = 0 ;
25292 PyObject * obj2 = 0 ;
25293 PyObject * obj3 = 0 ;
25294 char * kwnames[] = {
25295 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25296 };
25297
25298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25300 if (!SWIG_IsOK(res1)) {
25301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25302 }
25303 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25304 ecode2 = SWIG_AsVal_int(obj1, &val2);
25305 if (!SWIG_IsOK(ecode2)) {
25306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25307 }
25308 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25309 if (obj2) {
25310 ecode3 = SWIG_AsVal_int(obj2, &val3);
25311 if (!SWIG_IsOK(ecode3)) {
25312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25313 }
25314 arg3 = static_cast< wxDateTime::Month >(val3);
25315 }
25316 if (obj3) {
25317 ecode4 = SWIG_AsVal_int(obj3, &val4);
25318 if (!SWIG_IsOK(ecode4)) {
25319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25320 }
25321 arg4 = static_cast< int >(val4);
25322 }
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 {
25330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25331 }
25332 return resultobj;
25333 fail:
25334 return NULL;
25335 }
25336
25337
25338 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25339 PyObject *resultobj = 0;
25340 wxDateTime *arg1 = (wxDateTime *) 0 ;
25341 wxDateTime::WeekDay arg2 ;
25342 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25343 int arg4 = (int) wxDateTime::Inv_Year ;
25344 wxDateTime result;
25345 void *argp1 = 0 ;
25346 int res1 = 0 ;
25347 int val2 ;
25348 int ecode2 = 0 ;
25349 int val3 ;
25350 int ecode3 = 0 ;
25351 int val4 ;
25352 int ecode4 = 0 ;
25353 PyObject * obj0 = 0 ;
25354 PyObject * obj1 = 0 ;
25355 PyObject * obj2 = 0 ;
25356 PyObject * obj3 = 0 ;
25357 char * kwnames[] = {
25358 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25359 };
25360
25361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25363 if (!SWIG_IsOK(res1)) {
25364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25365 }
25366 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25367 ecode2 = SWIG_AsVal_int(obj1, &val2);
25368 if (!SWIG_IsOK(ecode2)) {
25369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25370 }
25371 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25372 if (obj2) {
25373 ecode3 = SWIG_AsVal_int(obj2, &val3);
25374 if (!SWIG_IsOK(ecode3)) {
25375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25376 }
25377 arg3 = static_cast< wxDateTime::Month >(val3);
25378 }
25379 if (obj3) {
25380 ecode4 = SWIG_AsVal_int(obj3, &val4);
25381 if (!SWIG_IsOK(ecode4)) {
25382 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25383 }
25384 arg4 = static_cast< int >(val4);
25385 }
25386 {
25387 PyThreadState* __tstate = wxPyBeginAllowThreads();
25388 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25389 wxPyEndAllowThreads(__tstate);
25390 if (PyErr_Occurred()) SWIG_fail;
25391 }
25392 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25393 return resultobj;
25394 fail:
25395 return NULL;
25396 }
25397
25398
25399 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25400 PyObject *resultobj = 0;
25401 int arg1 ;
25402 int arg2 ;
25403 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25404 wxDateTime result;
25405 int val1 ;
25406 int ecode1 = 0 ;
25407 int val2 ;
25408 int ecode2 = 0 ;
25409 int val3 ;
25410 int ecode3 = 0 ;
25411 PyObject * obj0 = 0 ;
25412 PyObject * obj1 = 0 ;
25413 PyObject * obj2 = 0 ;
25414 char * kwnames[] = {
25415 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25416 };
25417
25418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25419 ecode1 = SWIG_AsVal_int(obj0, &val1);
25420 if (!SWIG_IsOK(ecode1)) {
25421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25422 }
25423 arg1 = static_cast< int >(val1);
25424 ecode2 = SWIG_AsVal_int(obj1, &val2);
25425 if (!SWIG_IsOK(ecode2)) {
25426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25427 }
25428 arg2 = static_cast< int >(val2);
25429 if (obj2) {
25430 ecode3 = SWIG_AsVal_int(obj2, &val3);
25431 if (!SWIG_IsOK(ecode3)) {
25432 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25433 }
25434 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25435 }
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25450 PyObject *resultobj = 0;
25451 wxDateTime *arg1 = (wxDateTime *) 0 ;
25452 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25453 int arg3 = (int) wxDateTime::Inv_Year ;
25454 wxDateTime *result = 0 ;
25455 void *argp1 = 0 ;
25456 int res1 = 0 ;
25457 int val2 ;
25458 int ecode2 = 0 ;
25459 int val3 ;
25460 int ecode3 = 0 ;
25461 PyObject * obj0 = 0 ;
25462 PyObject * obj1 = 0 ;
25463 PyObject * obj2 = 0 ;
25464 char * kwnames[] = {
25465 (char *) "self",(char *) "month",(char *) "year", NULL
25466 };
25467
25468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25470 if (!SWIG_IsOK(res1)) {
25471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25472 }
25473 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25474 if (obj1) {
25475 ecode2 = SWIG_AsVal_int(obj1, &val2);
25476 if (!SWIG_IsOK(ecode2)) {
25477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25478 }
25479 arg2 = static_cast< wxDateTime::Month >(val2);
25480 }
25481 if (obj2) {
25482 ecode3 = SWIG_AsVal_int(obj2, &val3);
25483 if (!SWIG_IsOK(ecode3)) {
25484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25485 }
25486 arg3 = static_cast< int >(val3);
25487 }
25488 {
25489 PyThreadState* __tstate = wxPyBeginAllowThreads();
25490 {
25491 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25492 result = (wxDateTime *) &_result_ref;
25493 }
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25498 return resultobj;
25499 fail:
25500 return NULL;
25501 }
25502
25503
25504 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25505 PyObject *resultobj = 0;
25506 wxDateTime *arg1 = (wxDateTime *) 0 ;
25507 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25508 int arg3 = (int) wxDateTime::Inv_Year ;
25509 wxDateTime result;
25510 void *argp1 = 0 ;
25511 int res1 = 0 ;
25512 int val2 ;
25513 int ecode2 = 0 ;
25514 int val3 ;
25515 int ecode3 = 0 ;
25516 PyObject * obj0 = 0 ;
25517 PyObject * obj1 = 0 ;
25518 PyObject * obj2 = 0 ;
25519 char * kwnames[] = {
25520 (char *) "self",(char *) "month",(char *) "year", NULL
25521 };
25522
25523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25525 if (!SWIG_IsOK(res1)) {
25526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25527 }
25528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25529 if (obj1) {
25530 ecode2 = SWIG_AsVal_int(obj1, &val2);
25531 if (!SWIG_IsOK(ecode2)) {
25532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25533 }
25534 arg2 = static_cast< wxDateTime::Month >(val2);
25535 }
25536 if (obj2) {
25537 ecode3 = SWIG_AsVal_int(obj2, &val3);
25538 if (!SWIG_IsOK(ecode3)) {
25539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25540 }
25541 arg3 = static_cast< int >(val3);
25542 }
25543 {
25544 PyThreadState* __tstate = wxPyBeginAllowThreads();
25545 result = (arg1)->GetLastMonthDay(arg2,arg3);
25546 wxPyEndAllowThreads(__tstate);
25547 if (PyErr_Occurred()) SWIG_fail;
25548 }
25549 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25557 PyObject *resultobj = 0;
25558 wxDateTime *arg1 = (wxDateTime *) 0 ;
25559 int arg2 ;
25560 wxDateTime *result = 0 ;
25561 void *argp1 = 0 ;
25562 int res1 = 0 ;
25563 int val2 ;
25564 int ecode2 = 0 ;
25565 PyObject * obj0 = 0 ;
25566 PyObject * obj1 = 0 ;
25567 char * kwnames[] = {
25568 (char *) "self",(char *) "yday", NULL
25569 };
25570
25571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25573 if (!SWIG_IsOK(res1)) {
25574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25575 }
25576 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25577 ecode2 = SWIG_AsVal_int(obj1, &val2);
25578 if (!SWIG_IsOK(ecode2)) {
25579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25580 }
25581 arg2 = static_cast< int >(val2);
25582 {
25583 PyThreadState* __tstate = wxPyBeginAllowThreads();
25584 {
25585 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25586 result = (wxDateTime *) &_result_ref;
25587 }
25588 wxPyEndAllowThreads(__tstate);
25589 if (PyErr_Occurred()) SWIG_fail;
25590 }
25591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25592 return resultobj;
25593 fail:
25594 return NULL;
25595 }
25596
25597
25598 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25599 PyObject *resultobj = 0;
25600 wxDateTime *arg1 = (wxDateTime *) 0 ;
25601 int arg2 ;
25602 wxDateTime result;
25603 void *argp1 = 0 ;
25604 int res1 = 0 ;
25605 int val2 ;
25606 int ecode2 = 0 ;
25607 PyObject * obj0 = 0 ;
25608 PyObject * obj1 = 0 ;
25609 char * kwnames[] = {
25610 (char *) "self",(char *) "yday", NULL
25611 };
25612
25613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25615 if (!SWIG_IsOK(res1)) {
25616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25617 }
25618 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25619 ecode2 = SWIG_AsVal_int(obj1, &val2);
25620 if (!SWIG_IsOK(ecode2)) {
25621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25622 }
25623 arg2 = static_cast< int >(val2);
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = (arg1)->GetYearDay(arg2);
25627 wxPyEndAllowThreads(__tstate);
25628 if (PyErr_Occurred()) SWIG_fail;
25629 }
25630 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25631 return resultobj;
25632 fail:
25633 return NULL;
25634 }
25635
25636
25637 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25638 PyObject *resultobj = 0;
25639 wxDateTime *arg1 = (wxDateTime *) 0 ;
25640 double result;
25641 void *argp1 = 0 ;
25642 int res1 = 0 ;
25643 PyObject *swig_obj[1] ;
25644
25645 if (!args) SWIG_fail;
25646 swig_obj[0] = args;
25647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25648 if (!SWIG_IsOK(res1)) {
25649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25650 }
25651 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25652 {
25653 PyThreadState* __tstate = wxPyBeginAllowThreads();
25654 result = (double)(arg1)->GetJulianDayNumber();
25655 wxPyEndAllowThreads(__tstate);
25656 if (PyErr_Occurred()) SWIG_fail;
25657 }
25658 resultobj = SWIG_From_double(static_cast< double >(result));
25659 return resultobj;
25660 fail:
25661 return NULL;
25662 }
25663
25664
25665 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25666 PyObject *resultobj = 0;
25667 wxDateTime *arg1 = (wxDateTime *) 0 ;
25668 double result;
25669 void *argp1 = 0 ;
25670 int res1 = 0 ;
25671 PyObject *swig_obj[1] ;
25672
25673 if (!args) SWIG_fail;
25674 swig_obj[0] = args;
25675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25676 if (!SWIG_IsOK(res1)) {
25677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25678 }
25679 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25680 {
25681 PyThreadState* __tstate = wxPyBeginAllowThreads();
25682 result = (double)(arg1)->GetJDN();
25683 wxPyEndAllowThreads(__tstate);
25684 if (PyErr_Occurred()) SWIG_fail;
25685 }
25686 resultobj = SWIG_From_double(static_cast< double >(result));
25687 return resultobj;
25688 fail:
25689 return NULL;
25690 }
25691
25692
25693 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25694 PyObject *resultobj = 0;
25695 wxDateTime *arg1 = (wxDateTime *) 0 ;
25696 double result;
25697 void *argp1 = 0 ;
25698 int res1 = 0 ;
25699 PyObject *swig_obj[1] ;
25700
25701 if (!args) SWIG_fail;
25702 swig_obj[0] = args;
25703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25704 if (!SWIG_IsOK(res1)) {
25705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25706 }
25707 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25708 {
25709 PyThreadState* __tstate = wxPyBeginAllowThreads();
25710 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25711 wxPyEndAllowThreads(__tstate);
25712 if (PyErr_Occurred()) SWIG_fail;
25713 }
25714 resultobj = SWIG_From_double(static_cast< double >(result));
25715 return resultobj;
25716 fail:
25717 return NULL;
25718 }
25719
25720
25721 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25722 PyObject *resultobj = 0;
25723 wxDateTime *arg1 = (wxDateTime *) 0 ;
25724 double result;
25725 void *argp1 = 0 ;
25726 int res1 = 0 ;
25727 PyObject *swig_obj[1] ;
25728
25729 if (!args) SWIG_fail;
25730 swig_obj[0] = args;
25731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25732 if (!SWIG_IsOK(res1)) {
25733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25734 }
25735 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25736 {
25737 PyThreadState* __tstate = wxPyBeginAllowThreads();
25738 result = (double)(arg1)->GetMJD();
25739 wxPyEndAllowThreads(__tstate);
25740 if (PyErr_Occurred()) SWIG_fail;
25741 }
25742 resultobj = SWIG_From_double(static_cast< double >(result));
25743 return resultobj;
25744 fail:
25745 return NULL;
25746 }
25747
25748
25749 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25750 PyObject *resultobj = 0;
25751 wxDateTime *arg1 = (wxDateTime *) 0 ;
25752 double result;
25753 void *argp1 = 0 ;
25754 int res1 = 0 ;
25755 PyObject *swig_obj[1] ;
25756
25757 if (!args) SWIG_fail;
25758 swig_obj[0] = args;
25759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25760 if (!SWIG_IsOK(res1)) {
25761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25762 }
25763 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 result = (double)(arg1)->GetRataDie();
25767 wxPyEndAllowThreads(__tstate);
25768 if (PyErr_Occurred()) SWIG_fail;
25769 }
25770 resultobj = SWIG_From_double(static_cast< double >(result));
25771 return resultobj;
25772 fail:
25773 return NULL;
25774 }
25775
25776
25777 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25778 PyObject *resultobj = 0;
25779 wxDateTime *arg1 = (wxDateTime *) 0 ;
25780 wxDateTime::TimeZone *arg2 = 0 ;
25781 bool arg3 = (bool) false ;
25782 wxDateTime result;
25783 void *argp1 = 0 ;
25784 int res1 = 0 ;
25785 bool temp2 = false ;
25786 bool val3 ;
25787 int ecode3 = 0 ;
25788 PyObject * obj0 = 0 ;
25789 PyObject * obj1 = 0 ;
25790 PyObject * obj2 = 0 ;
25791 char * kwnames[] = {
25792 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25793 };
25794
25795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25797 if (!SWIG_IsOK(res1)) {
25798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25799 }
25800 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25801 {
25802 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25803 temp2 = true;
25804 }
25805 if (obj2) {
25806 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25807 if (!SWIG_IsOK(ecode3)) {
25808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25809 }
25810 arg3 = static_cast< bool >(val3);
25811 }
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 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_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25832 PyObject *resultobj = 0;
25833 wxDateTime *arg1 = (wxDateTime *) 0 ;
25834 wxDateTime::TimeZone *arg2 = 0 ;
25835 bool arg3 = (bool) false ;
25836 wxDateTime *result = 0 ;
25837 void *argp1 = 0 ;
25838 int res1 = 0 ;
25839 bool temp2 = false ;
25840 bool val3 ;
25841 int ecode3 = 0 ;
25842 PyObject * obj0 = 0 ;
25843 PyObject * obj1 = 0 ;
25844 PyObject * obj2 = 0 ;
25845 char * kwnames[] = {
25846 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25847 };
25848
25849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25851 if (!SWIG_IsOK(res1)) {
25852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25853 }
25854 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25855 {
25856 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25857 temp2 = true;
25858 }
25859 if (obj2) {
25860 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25861 if (!SWIG_IsOK(ecode3)) {
25862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25863 }
25864 arg3 = static_cast< bool >(val3);
25865 }
25866 {
25867 PyThreadState* __tstate = wxPyBeginAllowThreads();
25868 {
25869 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25870 result = (wxDateTime *) &_result_ref;
25871 }
25872 wxPyEndAllowThreads(__tstate);
25873 if (PyErr_Occurred()) SWIG_fail;
25874 }
25875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25876 {
25877 if (temp2) delete arg2;
25878 }
25879 return resultobj;
25880 fail:
25881 {
25882 if (temp2) delete arg2;
25883 }
25884 return NULL;
25885 }
25886
25887
25888 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25889 PyObject *resultobj = 0;
25890 wxDateTime *arg1 = (wxDateTime *) 0 ;
25891 wxDateTime::TimeZone *arg2 = 0 ;
25892 bool arg3 = (bool) false ;
25893 wxDateTime result;
25894 void *argp1 = 0 ;
25895 int res1 = 0 ;
25896 bool temp2 = false ;
25897 bool val3 ;
25898 int ecode3 = 0 ;
25899 PyObject * obj0 = 0 ;
25900 PyObject * obj1 = 0 ;
25901 PyObject * obj2 = 0 ;
25902 char * kwnames[] = {
25903 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25904 };
25905
25906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25908 if (!SWIG_IsOK(res1)) {
25909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25910 }
25911 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25912 {
25913 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25914 temp2 = true;
25915 }
25916 if (obj2) {
25917 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25918 if (!SWIG_IsOK(ecode3)) {
25919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25920 }
25921 arg3 = static_cast< bool >(val3);
25922 }
25923 {
25924 PyThreadState* __tstate = wxPyBeginAllowThreads();
25925 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25926 wxPyEndAllowThreads(__tstate);
25927 if (PyErr_Occurred()) SWIG_fail;
25928 }
25929 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25930 {
25931 if (temp2) delete arg2;
25932 }
25933 return resultobj;
25934 fail:
25935 {
25936 if (temp2) delete arg2;
25937 }
25938 return NULL;
25939 }
25940
25941
25942 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25943 PyObject *resultobj = 0;
25944 wxDateTime *arg1 = (wxDateTime *) 0 ;
25945 wxDateTime::TimeZone *arg2 = 0 ;
25946 bool arg3 = (bool) false ;
25947 wxDateTime *result = 0 ;
25948 void *argp1 = 0 ;
25949 int res1 = 0 ;
25950 bool temp2 = false ;
25951 bool val3 ;
25952 int ecode3 = 0 ;
25953 PyObject * obj0 = 0 ;
25954 PyObject * obj1 = 0 ;
25955 PyObject * obj2 = 0 ;
25956 char * kwnames[] = {
25957 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25958 };
25959
25960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25962 if (!SWIG_IsOK(res1)) {
25963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25964 }
25965 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25966 {
25967 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25968 temp2 = true;
25969 }
25970 if (obj2) {
25971 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25972 if (!SWIG_IsOK(ecode3)) {
25973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25974 }
25975 arg3 = static_cast< bool >(val3);
25976 }
25977 {
25978 PyThreadState* __tstate = wxPyBeginAllowThreads();
25979 {
25980 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25981 result = (wxDateTime *) &_result_ref;
25982 }
25983 wxPyEndAllowThreads(__tstate);
25984 if (PyErr_Occurred()) SWIG_fail;
25985 }
25986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25987 {
25988 if (temp2) delete arg2;
25989 }
25990 return resultobj;
25991 fail:
25992 {
25993 if (temp2) delete arg2;
25994 }
25995 return NULL;
25996 }
25997
25998
25999 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26000 PyObject *resultobj = 0;
26001 wxDateTime *arg1 = (wxDateTime *) 0 ;
26002 bool arg2 = (bool) false ;
26003 wxDateTime result;
26004 void *argp1 = 0 ;
26005 int res1 = 0 ;
26006 bool val2 ;
26007 int ecode2 = 0 ;
26008 PyObject * obj0 = 0 ;
26009 PyObject * obj1 = 0 ;
26010 char * kwnames[] = {
26011 (char *) "self",(char *) "noDST", NULL
26012 };
26013
26014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26016 if (!SWIG_IsOK(res1)) {
26017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26018 }
26019 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26020 if (obj1) {
26021 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26022 if (!SWIG_IsOK(ecode2)) {
26023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
26024 }
26025 arg2 = static_cast< bool >(val2);
26026 }
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26041 PyObject *resultobj = 0;
26042 wxDateTime *arg1 = (wxDateTime *) 0 ;
26043 bool arg2 = (bool) false ;
26044 wxDateTime *result = 0 ;
26045 void *argp1 = 0 ;
26046 int res1 = 0 ;
26047 bool val2 ;
26048 int ecode2 = 0 ;
26049 PyObject * obj0 = 0 ;
26050 PyObject * obj1 = 0 ;
26051 char * kwnames[] = {
26052 (char *) "self",(char *) "noDST", NULL
26053 };
26054
26055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26057 if (!SWIG_IsOK(res1)) {
26058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26059 }
26060 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26061 if (obj1) {
26062 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26063 if (!SWIG_IsOK(ecode2)) {
26064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
26065 }
26066 arg2 = static_cast< bool >(val2);
26067 }
26068 {
26069 PyThreadState* __tstate = wxPyBeginAllowThreads();
26070 {
26071 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
26072 result = (wxDateTime *) &_result_ref;
26073 }
26074 wxPyEndAllowThreads(__tstate);
26075 if (PyErr_Occurred()) SWIG_fail;
26076 }
26077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26078 return resultobj;
26079 fail:
26080 return NULL;
26081 }
26082
26083
26084 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26085 PyObject *resultobj = 0;
26086 wxDateTime *arg1 = (wxDateTime *) 0 ;
26087 bool arg2 = (bool) false ;
26088 wxDateTime result;
26089 void *argp1 = 0 ;
26090 int res1 = 0 ;
26091 bool val2 ;
26092 int ecode2 = 0 ;
26093 PyObject * obj0 = 0 ;
26094 PyObject * obj1 = 0 ;
26095 char * kwnames[] = {
26096 (char *) "self",(char *) "noDST", NULL
26097 };
26098
26099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26101 if (!SWIG_IsOK(res1)) {
26102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26103 }
26104 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26105 if (obj1) {
26106 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26107 if (!SWIG_IsOK(ecode2)) {
26108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26109 }
26110 arg2 = static_cast< bool >(val2);
26111 }
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26126 PyObject *resultobj = 0;
26127 wxDateTime *arg1 = (wxDateTime *) 0 ;
26128 bool arg2 = (bool) false ;
26129 wxDateTime *result = 0 ;
26130 void *argp1 = 0 ;
26131 int res1 = 0 ;
26132 bool val2 ;
26133 int ecode2 = 0 ;
26134 PyObject * obj0 = 0 ;
26135 PyObject * obj1 = 0 ;
26136 char * kwnames[] = {
26137 (char *) "self",(char *) "noDST", NULL
26138 };
26139
26140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26142 if (!SWIG_IsOK(res1)) {
26143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26144 }
26145 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26146 if (obj1) {
26147 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26148 if (!SWIG_IsOK(ecode2)) {
26149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26150 }
26151 arg2 = static_cast< bool >(val2);
26152 }
26153 {
26154 PyThreadState* __tstate = wxPyBeginAllowThreads();
26155 {
26156 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26157 result = (wxDateTime *) &_result_ref;
26158 }
26159 wxPyEndAllowThreads(__tstate);
26160 if (PyErr_Occurred()) SWIG_fail;
26161 }
26162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26163 return resultobj;
26164 fail:
26165 return NULL;
26166 }
26167
26168
26169 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26170 PyObject *resultobj = 0;
26171 wxDateTime *arg1 = (wxDateTime *) 0 ;
26172 bool arg2 = (bool) false ;
26173 wxDateTime result;
26174 void *argp1 = 0 ;
26175 int res1 = 0 ;
26176 bool val2 ;
26177 int ecode2 = 0 ;
26178 PyObject * obj0 = 0 ;
26179 PyObject * obj1 = 0 ;
26180 char * kwnames[] = {
26181 (char *) "self",(char *) "noDST", NULL
26182 };
26183
26184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26186 if (!SWIG_IsOK(res1)) {
26187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26188 }
26189 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26190 if (obj1) {
26191 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26192 if (!SWIG_IsOK(ecode2)) {
26193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26194 }
26195 arg2 = static_cast< bool >(val2);
26196 }
26197 {
26198 PyThreadState* __tstate = wxPyBeginAllowThreads();
26199 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26200 wxPyEndAllowThreads(__tstate);
26201 if (PyErr_Occurred()) SWIG_fail;
26202 }
26203 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26204 return resultobj;
26205 fail:
26206 return NULL;
26207 }
26208
26209
26210 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26211 PyObject *resultobj = 0;
26212 wxDateTime *arg1 = (wxDateTime *) 0 ;
26213 bool arg2 = (bool) false ;
26214 wxDateTime *result = 0 ;
26215 void *argp1 = 0 ;
26216 int res1 = 0 ;
26217 bool val2 ;
26218 int ecode2 = 0 ;
26219 PyObject * obj0 = 0 ;
26220 PyObject * obj1 = 0 ;
26221 char * kwnames[] = {
26222 (char *) "self",(char *) "noDST", NULL
26223 };
26224
26225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26227 if (!SWIG_IsOK(res1)) {
26228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26229 }
26230 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26231 if (obj1) {
26232 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26233 if (!SWIG_IsOK(ecode2)) {
26234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26235 }
26236 arg2 = static_cast< bool >(val2);
26237 }
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 {
26241 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26242 result = (wxDateTime *) &_result_ref;
26243 }
26244 wxPyEndAllowThreads(__tstate);
26245 if (PyErr_Occurred()) SWIG_fail;
26246 }
26247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26248 return resultobj;
26249 fail:
26250 return NULL;
26251 }
26252
26253
26254 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26255 PyObject *resultobj = 0;
26256 wxDateTime *arg1 = (wxDateTime *) 0 ;
26257 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26258 int result;
26259 void *argp1 = 0 ;
26260 int res1 = 0 ;
26261 int val2 ;
26262 int ecode2 = 0 ;
26263 PyObject * obj0 = 0 ;
26264 PyObject * obj1 = 0 ;
26265 char * kwnames[] = {
26266 (char *) "self",(char *) "country", NULL
26267 };
26268
26269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26271 if (!SWIG_IsOK(res1)) {
26272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26273 }
26274 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26275 if (obj1) {
26276 ecode2 = SWIG_AsVal_int(obj1, &val2);
26277 if (!SWIG_IsOK(ecode2)) {
26278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26279 }
26280 arg2 = static_cast< wxDateTime::Country >(val2);
26281 }
26282 {
26283 PyThreadState* __tstate = wxPyBeginAllowThreads();
26284 result = (int)(arg1)->IsDST(arg2);
26285 wxPyEndAllowThreads(__tstate);
26286 if (PyErr_Occurred()) SWIG_fail;
26287 }
26288 resultobj = SWIG_From_int(static_cast< int >(result));
26289 return resultobj;
26290 fail:
26291 return NULL;
26292 }
26293
26294
26295 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26296 PyObject *resultobj = 0;
26297 wxDateTime *arg1 = (wxDateTime *) 0 ;
26298 bool result;
26299 void *argp1 = 0 ;
26300 int res1 = 0 ;
26301 PyObject *swig_obj[1] ;
26302
26303 if (!args) SWIG_fail;
26304 swig_obj[0] = args;
26305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26306 if (!SWIG_IsOK(res1)) {
26307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26308 }
26309 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26310 {
26311 PyThreadState* __tstate = wxPyBeginAllowThreads();
26312 result = (bool)((wxDateTime const *)arg1)->IsValid();
26313 wxPyEndAllowThreads(__tstate);
26314 if (PyErr_Occurred()) SWIG_fail;
26315 }
26316 {
26317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26318 }
26319 return resultobj;
26320 fail:
26321 return NULL;
26322 }
26323
26324
26325 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26326 PyObject *resultobj = 0;
26327 wxDateTime *arg1 = (wxDateTime *) 0 ;
26328 time_t result;
26329 void *argp1 = 0 ;
26330 int res1 = 0 ;
26331 PyObject *swig_obj[1] ;
26332
26333 if (!args) SWIG_fail;
26334 swig_obj[0] = args;
26335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26336 if (!SWIG_IsOK(res1)) {
26337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26338 }
26339 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26340 {
26341 PyThreadState* __tstate = wxPyBeginAllowThreads();
26342 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26343 wxPyEndAllowThreads(__tstate);
26344 if (PyErr_Occurred()) SWIG_fail;
26345 }
26346 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26354 PyObject *resultobj = 0;
26355 wxDateTime *arg1 = (wxDateTime *) 0 ;
26356 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26357 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26358 int result;
26359 void *argp1 = 0 ;
26360 int res1 = 0 ;
26361 bool temp2 = false ;
26362 PyObject * obj0 = 0 ;
26363 PyObject * obj1 = 0 ;
26364 char * kwnames[] = {
26365 (char *) "self",(char *) "tz", NULL
26366 };
26367
26368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26370 if (!SWIG_IsOK(res1)) {
26371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26372 }
26373 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26374 if (obj1) {
26375 {
26376 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26377 temp2 = true;
26378 }
26379 }
26380 {
26381 PyThreadState* __tstate = wxPyBeginAllowThreads();
26382 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26383 wxPyEndAllowThreads(__tstate);
26384 if (PyErr_Occurred()) SWIG_fail;
26385 }
26386 resultobj = SWIG_From_int(static_cast< int >(result));
26387 {
26388 if (temp2) delete arg2;
26389 }
26390 return resultobj;
26391 fail:
26392 {
26393 if (temp2) delete arg2;
26394 }
26395 return NULL;
26396 }
26397
26398
26399 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26400 PyObject *resultobj = 0;
26401 wxDateTime *arg1 = (wxDateTime *) 0 ;
26402 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26403 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26404 wxDateTime::Month result;
26405 void *argp1 = 0 ;
26406 int res1 = 0 ;
26407 bool temp2 = false ;
26408 PyObject * obj0 = 0 ;
26409 PyObject * obj1 = 0 ;
26410 char * kwnames[] = {
26411 (char *) "self",(char *) "tz", NULL
26412 };
26413
26414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26416 if (!SWIG_IsOK(res1)) {
26417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26418 }
26419 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26420 if (obj1) {
26421 {
26422 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26423 temp2 = true;
26424 }
26425 }
26426 {
26427 PyThreadState* __tstate = wxPyBeginAllowThreads();
26428 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26429 wxPyEndAllowThreads(__tstate);
26430 if (PyErr_Occurred()) SWIG_fail;
26431 }
26432 resultobj = SWIG_From_int(static_cast< int >(result));
26433 {
26434 if (temp2) delete arg2;
26435 }
26436 return resultobj;
26437 fail:
26438 {
26439 if (temp2) delete arg2;
26440 }
26441 return NULL;
26442 }
26443
26444
26445 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26446 PyObject *resultobj = 0;
26447 wxDateTime *arg1 = (wxDateTime *) 0 ;
26448 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26449 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26450 int result;
26451 void *argp1 = 0 ;
26452 int res1 = 0 ;
26453 bool temp2 = false ;
26454 PyObject * obj0 = 0 ;
26455 PyObject * obj1 = 0 ;
26456 char * kwnames[] = {
26457 (char *) "self",(char *) "tz", NULL
26458 };
26459
26460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26462 if (!SWIG_IsOK(res1)) {
26463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26464 }
26465 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26466 if (obj1) {
26467 {
26468 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26469 temp2 = true;
26470 }
26471 }
26472 {
26473 PyThreadState* __tstate = wxPyBeginAllowThreads();
26474 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26475 wxPyEndAllowThreads(__tstate);
26476 if (PyErr_Occurred()) SWIG_fail;
26477 }
26478 resultobj = SWIG_From_int(static_cast< int >(result));
26479 {
26480 if (temp2) delete arg2;
26481 }
26482 return resultobj;
26483 fail:
26484 {
26485 if (temp2) delete arg2;
26486 }
26487 return NULL;
26488 }
26489
26490
26491 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26492 PyObject *resultobj = 0;
26493 wxDateTime *arg1 = (wxDateTime *) 0 ;
26494 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26495 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26496 wxDateTime::WeekDay result;
26497 void *argp1 = 0 ;
26498 int res1 = 0 ;
26499 bool temp2 = false ;
26500 PyObject * obj0 = 0 ;
26501 PyObject * obj1 = 0 ;
26502 char * kwnames[] = {
26503 (char *) "self",(char *) "tz", NULL
26504 };
26505
26506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26508 if (!SWIG_IsOK(res1)) {
26509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26510 }
26511 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26512 if (obj1) {
26513 {
26514 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26515 temp2 = true;
26516 }
26517 }
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 resultobj = SWIG_From_int(static_cast< int >(result));
26525 {
26526 if (temp2) delete arg2;
26527 }
26528 return resultobj;
26529 fail:
26530 {
26531 if (temp2) delete arg2;
26532 }
26533 return NULL;
26534 }
26535
26536
26537 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26538 PyObject *resultobj = 0;
26539 wxDateTime *arg1 = (wxDateTime *) 0 ;
26540 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26541 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26542 int result;
26543 void *argp1 = 0 ;
26544 int res1 = 0 ;
26545 bool temp2 = false ;
26546 PyObject * obj0 = 0 ;
26547 PyObject * obj1 = 0 ;
26548 char * kwnames[] = {
26549 (char *) "self",(char *) "tz", NULL
26550 };
26551
26552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26554 if (!SWIG_IsOK(res1)) {
26555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26556 }
26557 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26558 if (obj1) {
26559 {
26560 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26561 temp2 = true;
26562 }
26563 }
26564 {
26565 PyThreadState* __tstate = wxPyBeginAllowThreads();
26566 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26567 wxPyEndAllowThreads(__tstate);
26568 if (PyErr_Occurred()) SWIG_fail;
26569 }
26570 resultobj = SWIG_From_int(static_cast< int >(result));
26571 {
26572 if (temp2) delete arg2;
26573 }
26574 return resultobj;
26575 fail:
26576 {
26577 if (temp2) delete arg2;
26578 }
26579 return NULL;
26580 }
26581
26582
26583 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26584 PyObject *resultobj = 0;
26585 wxDateTime *arg1 = (wxDateTime *) 0 ;
26586 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26587 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26588 int result;
26589 void *argp1 = 0 ;
26590 int res1 = 0 ;
26591 bool temp2 = false ;
26592 PyObject * obj0 = 0 ;
26593 PyObject * obj1 = 0 ;
26594 char * kwnames[] = {
26595 (char *) "self",(char *) "tz", NULL
26596 };
26597
26598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26600 if (!SWIG_IsOK(res1)) {
26601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26602 }
26603 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26604 if (obj1) {
26605 {
26606 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26607 temp2 = true;
26608 }
26609 }
26610 {
26611 PyThreadState* __tstate = wxPyBeginAllowThreads();
26612 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26613 wxPyEndAllowThreads(__tstate);
26614 if (PyErr_Occurred()) SWIG_fail;
26615 }
26616 resultobj = SWIG_From_int(static_cast< int >(result));
26617 {
26618 if (temp2) delete arg2;
26619 }
26620 return resultobj;
26621 fail:
26622 {
26623 if (temp2) delete arg2;
26624 }
26625 return NULL;
26626 }
26627
26628
26629 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26630 PyObject *resultobj = 0;
26631 wxDateTime *arg1 = (wxDateTime *) 0 ;
26632 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26633 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26634 int result;
26635 void *argp1 = 0 ;
26636 int res1 = 0 ;
26637 bool temp2 = false ;
26638 PyObject * obj0 = 0 ;
26639 PyObject * obj1 = 0 ;
26640 char * kwnames[] = {
26641 (char *) "self",(char *) "tz", NULL
26642 };
26643
26644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26646 if (!SWIG_IsOK(res1)) {
26647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26648 }
26649 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26650 if (obj1) {
26651 {
26652 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26653 temp2 = true;
26654 }
26655 }
26656 {
26657 PyThreadState* __tstate = wxPyBeginAllowThreads();
26658 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26659 wxPyEndAllowThreads(__tstate);
26660 if (PyErr_Occurred()) SWIG_fail;
26661 }
26662 resultobj = SWIG_From_int(static_cast< int >(result));
26663 {
26664 if (temp2) delete arg2;
26665 }
26666 return resultobj;
26667 fail:
26668 {
26669 if (temp2) delete arg2;
26670 }
26671 return NULL;
26672 }
26673
26674
26675 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26676 PyObject *resultobj = 0;
26677 wxDateTime *arg1 = (wxDateTime *) 0 ;
26678 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26679 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26680 int result;
26681 void *argp1 = 0 ;
26682 int res1 = 0 ;
26683 bool temp2 = false ;
26684 PyObject * obj0 = 0 ;
26685 PyObject * obj1 = 0 ;
26686 char * kwnames[] = {
26687 (char *) "self",(char *) "tz", NULL
26688 };
26689
26690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26692 if (!SWIG_IsOK(res1)) {
26693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26694 }
26695 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26696 if (obj1) {
26697 {
26698 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26699 temp2 = true;
26700 }
26701 }
26702 {
26703 PyThreadState* __tstate = wxPyBeginAllowThreads();
26704 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26705 wxPyEndAllowThreads(__tstate);
26706 if (PyErr_Occurred()) SWIG_fail;
26707 }
26708 resultobj = SWIG_From_int(static_cast< int >(result));
26709 {
26710 if (temp2) delete arg2;
26711 }
26712 return resultobj;
26713 fail:
26714 {
26715 if (temp2) delete arg2;
26716 }
26717 return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26722 PyObject *resultobj = 0;
26723 wxDateTime *arg1 = (wxDateTime *) 0 ;
26724 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26725 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26726 int result;
26727 void *argp1 = 0 ;
26728 int res1 = 0 ;
26729 bool temp2 = false ;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732 char * kwnames[] = {
26733 (char *) "self",(char *) "tz", NULL
26734 };
26735
26736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26738 if (!SWIG_IsOK(res1)) {
26739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26740 }
26741 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26742 if (obj1) {
26743 {
26744 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26745 temp2 = true;
26746 }
26747 }
26748 {
26749 PyThreadState* __tstate = wxPyBeginAllowThreads();
26750 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26751 wxPyEndAllowThreads(__tstate);
26752 if (PyErr_Occurred()) SWIG_fail;
26753 }
26754 resultobj = SWIG_From_int(static_cast< int >(result));
26755 {
26756 if (temp2) delete arg2;
26757 }
26758 return resultobj;
26759 fail:
26760 {
26761 if (temp2) delete arg2;
26762 }
26763 return NULL;
26764 }
26765
26766
26767 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26768 PyObject *resultobj = 0;
26769 wxDateTime *arg1 = (wxDateTime *) 0 ;
26770 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26771 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26772 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26773 int result;
26774 void *argp1 = 0 ;
26775 int res1 = 0 ;
26776 int val2 ;
26777 int ecode2 = 0 ;
26778 bool temp3 = false ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 PyObject * obj2 = 0 ;
26782 char * kwnames[] = {
26783 (char *) "self",(char *) "flags",(char *) "tz", NULL
26784 };
26785
26786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26788 if (!SWIG_IsOK(res1)) {
26789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26790 }
26791 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26792 if (obj1) {
26793 ecode2 = SWIG_AsVal_int(obj1, &val2);
26794 if (!SWIG_IsOK(ecode2)) {
26795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26796 }
26797 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26798 }
26799 if (obj2) {
26800 {
26801 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26802 temp3 = true;
26803 }
26804 }
26805 {
26806 PyThreadState* __tstate = wxPyBeginAllowThreads();
26807 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26808 wxPyEndAllowThreads(__tstate);
26809 if (PyErr_Occurred()) SWIG_fail;
26810 }
26811 resultobj = SWIG_From_int(static_cast< int >(result));
26812 {
26813 if (temp3) delete arg3;
26814 }
26815 return resultobj;
26816 fail:
26817 {
26818 if (temp3) delete arg3;
26819 }
26820 return NULL;
26821 }
26822
26823
26824 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26825 PyObject *resultobj = 0;
26826 wxDateTime *arg1 = (wxDateTime *) 0 ;
26827 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26828 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26829 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26830 int result;
26831 void *argp1 = 0 ;
26832 int res1 = 0 ;
26833 int val2 ;
26834 int ecode2 = 0 ;
26835 bool temp3 = false ;
26836 PyObject * obj0 = 0 ;
26837 PyObject * obj1 = 0 ;
26838 PyObject * obj2 = 0 ;
26839 char * kwnames[] = {
26840 (char *) "self",(char *) "flags",(char *) "tz", NULL
26841 };
26842
26843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26845 if (!SWIG_IsOK(res1)) {
26846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26847 }
26848 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26849 if (obj1) {
26850 ecode2 = SWIG_AsVal_int(obj1, &val2);
26851 if (!SWIG_IsOK(ecode2)) {
26852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26853 }
26854 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26855 }
26856 if (obj2) {
26857 {
26858 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26859 temp3 = true;
26860 }
26861 }
26862 {
26863 PyThreadState* __tstate = wxPyBeginAllowThreads();
26864 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26865 wxPyEndAllowThreads(__tstate);
26866 if (PyErr_Occurred()) SWIG_fail;
26867 }
26868 resultobj = SWIG_From_int(static_cast< int >(result));
26869 {
26870 if (temp3) delete arg3;
26871 }
26872 return resultobj;
26873 fail:
26874 {
26875 if (temp3) delete arg3;
26876 }
26877 return NULL;
26878 }
26879
26880
26881 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26882 PyObject *resultobj = 0;
26883 wxDateTime *arg1 = (wxDateTime *) 0 ;
26884 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26885 bool result;
26886 void *argp1 = 0 ;
26887 int res1 = 0 ;
26888 int val2 ;
26889 int ecode2 = 0 ;
26890 PyObject * obj0 = 0 ;
26891 PyObject * obj1 = 0 ;
26892 char * kwnames[] = {
26893 (char *) "self",(char *) "country", NULL
26894 };
26895
26896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26898 if (!SWIG_IsOK(res1)) {
26899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26900 }
26901 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26902 if (obj1) {
26903 ecode2 = SWIG_AsVal_int(obj1, &val2);
26904 if (!SWIG_IsOK(ecode2)) {
26905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26906 }
26907 arg2 = static_cast< wxDateTime::Country >(val2);
26908 }
26909 {
26910 PyThreadState* __tstate = wxPyBeginAllowThreads();
26911 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26912 wxPyEndAllowThreads(__tstate);
26913 if (PyErr_Occurred()) SWIG_fail;
26914 }
26915 {
26916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26917 }
26918 return resultobj;
26919 fail:
26920 return NULL;
26921 }
26922
26923
26924 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26925 PyObject *resultobj = 0;
26926 wxDateTime *arg1 = (wxDateTime *) 0 ;
26927 wxDateTime *arg2 = 0 ;
26928 bool result;
26929 void *argp1 = 0 ;
26930 int res1 = 0 ;
26931 void *argp2 = 0 ;
26932 int res2 = 0 ;
26933 PyObject * obj0 = 0 ;
26934 PyObject * obj1 = 0 ;
26935 char * kwnames[] = {
26936 (char *) "self",(char *) "datetime", NULL
26937 };
26938
26939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26941 if (!SWIG_IsOK(res1)) {
26942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26943 }
26944 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26946 if (!SWIG_IsOK(res2)) {
26947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26948 }
26949 if (!argp2) {
26950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26951 }
26952 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26953 {
26954 PyThreadState* __tstate = wxPyBeginAllowThreads();
26955 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26956 wxPyEndAllowThreads(__tstate);
26957 if (PyErr_Occurred()) SWIG_fail;
26958 }
26959 {
26960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26961 }
26962 return resultobj;
26963 fail:
26964 return NULL;
26965 }
26966
26967
26968 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26969 PyObject *resultobj = 0;
26970 wxDateTime *arg1 = (wxDateTime *) 0 ;
26971 wxDateTime *arg2 = 0 ;
26972 bool result;
26973 void *argp1 = 0 ;
26974 int res1 = 0 ;
26975 void *argp2 = 0 ;
26976 int res2 = 0 ;
26977 PyObject * obj0 = 0 ;
26978 PyObject * obj1 = 0 ;
26979 char * kwnames[] = {
26980 (char *) "self",(char *) "datetime", NULL
26981 };
26982
26983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26985 if (!SWIG_IsOK(res1)) {
26986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26987 }
26988 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26989 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26990 if (!SWIG_IsOK(res2)) {
26991 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26992 }
26993 if (!argp2) {
26994 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26995 }
26996 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26997 {
26998 PyThreadState* __tstate = wxPyBeginAllowThreads();
26999 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
27000 wxPyEndAllowThreads(__tstate);
27001 if (PyErr_Occurred()) SWIG_fail;
27002 }
27003 {
27004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27005 }
27006 return resultobj;
27007 fail:
27008 return NULL;
27009 }
27010
27011
27012 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27013 PyObject *resultobj = 0;
27014 wxDateTime *arg1 = (wxDateTime *) 0 ;
27015 wxDateTime *arg2 = 0 ;
27016 bool result;
27017 void *argp1 = 0 ;
27018 int res1 = 0 ;
27019 void *argp2 = 0 ;
27020 int res2 = 0 ;
27021 PyObject * obj0 = 0 ;
27022 PyObject * obj1 = 0 ;
27023 char * kwnames[] = {
27024 (char *) "self",(char *) "datetime", NULL
27025 };
27026
27027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
27028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27029 if (!SWIG_IsOK(res1)) {
27030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27031 }
27032 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27033 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27034 if (!SWIG_IsOK(res2)) {
27035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27036 }
27037 if (!argp2) {
27038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27039 }
27040 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
27044 wxPyEndAllowThreads(__tstate);
27045 if (PyErr_Occurred()) SWIG_fail;
27046 }
27047 {
27048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27049 }
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj = 0;
27058 wxDateTime *arg1 = (wxDateTime *) 0 ;
27059 wxDateTime *arg2 = 0 ;
27060 wxDateTime *arg3 = 0 ;
27061 bool result;
27062 void *argp1 = 0 ;
27063 int res1 = 0 ;
27064 void *argp2 = 0 ;
27065 int res2 = 0 ;
27066 void *argp3 = 0 ;
27067 int res3 = 0 ;
27068 PyObject * obj0 = 0 ;
27069 PyObject * obj1 = 0 ;
27070 PyObject * obj2 = 0 ;
27071 char * kwnames[] = {
27072 (char *) "self",(char *) "t1",(char *) "t2", NULL
27073 };
27074
27075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27077 if (!SWIG_IsOK(res1)) {
27078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27079 }
27080 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27081 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27082 if (!SWIG_IsOK(res2)) {
27083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27084 }
27085 if (!argp2) {
27086 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27087 }
27088 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27089 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27090 if (!SWIG_IsOK(res3)) {
27091 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27092 }
27093 if (!argp3) {
27094 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27095 }
27096 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27097 {
27098 PyThreadState* __tstate = wxPyBeginAllowThreads();
27099 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27100 wxPyEndAllowThreads(__tstate);
27101 if (PyErr_Occurred()) SWIG_fail;
27102 }
27103 {
27104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27105 }
27106 return resultobj;
27107 fail:
27108 return NULL;
27109 }
27110
27111
27112 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27113 PyObject *resultobj = 0;
27114 wxDateTime *arg1 = (wxDateTime *) 0 ;
27115 wxDateTime *arg2 = 0 ;
27116 wxDateTime *arg3 = 0 ;
27117 bool result;
27118 void *argp1 = 0 ;
27119 int res1 = 0 ;
27120 void *argp2 = 0 ;
27121 int res2 = 0 ;
27122 void *argp3 = 0 ;
27123 int res3 = 0 ;
27124 PyObject * obj0 = 0 ;
27125 PyObject * obj1 = 0 ;
27126 PyObject * obj2 = 0 ;
27127 char * kwnames[] = {
27128 (char *) "self",(char *) "t1",(char *) "t2", NULL
27129 };
27130
27131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27133 if (!SWIG_IsOK(res1)) {
27134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27135 }
27136 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27137 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27138 if (!SWIG_IsOK(res2)) {
27139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27140 }
27141 if (!argp2) {
27142 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27143 }
27144 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27145 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27146 if (!SWIG_IsOK(res3)) {
27147 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27148 }
27149 if (!argp3) {
27150 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27151 }
27152 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27153 {
27154 PyThreadState* __tstate = wxPyBeginAllowThreads();
27155 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27156 wxPyEndAllowThreads(__tstate);
27157 if (PyErr_Occurred()) SWIG_fail;
27158 }
27159 {
27160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27161 }
27162 return resultobj;
27163 fail:
27164 return NULL;
27165 }
27166
27167
27168 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27169 PyObject *resultobj = 0;
27170 wxDateTime *arg1 = (wxDateTime *) 0 ;
27171 wxDateTime *arg2 = 0 ;
27172 bool result;
27173 void *argp1 = 0 ;
27174 int res1 = 0 ;
27175 void *argp2 = 0 ;
27176 int res2 = 0 ;
27177 PyObject * obj0 = 0 ;
27178 PyObject * obj1 = 0 ;
27179 char * kwnames[] = {
27180 (char *) "self",(char *) "dt", NULL
27181 };
27182
27183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27185 if (!SWIG_IsOK(res1)) {
27186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27187 }
27188 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27189 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27190 if (!SWIG_IsOK(res2)) {
27191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27192 }
27193 if (!argp2) {
27194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27195 }
27196 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27197 {
27198 PyThreadState* __tstate = wxPyBeginAllowThreads();
27199 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 {
27204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27205 }
27206 return resultobj;
27207 fail:
27208 return NULL;
27209 }
27210
27211
27212 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27213 PyObject *resultobj = 0;
27214 wxDateTime *arg1 = (wxDateTime *) 0 ;
27215 wxDateTime *arg2 = 0 ;
27216 bool result;
27217 void *argp1 = 0 ;
27218 int res1 = 0 ;
27219 void *argp2 = 0 ;
27220 int res2 = 0 ;
27221 PyObject * obj0 = 0 ;
27222 PyObject * obj1 = 0 ;
27223 char * kwnames[] = {
27224 (char *) "self",(char *) "dt", NULL
27225 };
27226
27227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27229 if (!SWIG_IsOK(res1)) {
27230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27231 }
27232 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27233 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27234 if (!SWIG_IsOK(res2)) {
27235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27236 }
27237 if (!argp2) {
27238 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27239 }
27240 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27241 {
27242 PyThreadState* __tstate = wxPyBeginAllowThreads();
27243 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 {
27248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27249 }
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27257 PyObject *resultobj = 0;
27258 wxDateTime *arg1 = (wxDateTime *) 0 ;
27259 wxDateTime *arg2 = 0 ;
27260 wxTimeSpan *arg3 = 0 ;
27261 bool result;
27262 void *argp1 = 0 ;
27263 int res1 = 0 ;
27264 void *argp2 = 0 ;
27265 int res2 = 0 ;
27266 void *argp3 = 0 ;
27267 int res3 = 0 ;
27268 PyObject * obj0 = 0 ;
27269 PyObject * obj1 = 0 ;
27270 PyObject * obj2 = 0 ;
27271 char * kwnames[] = {
27272 (char *) "self",(char *) "dt",(char *) "ts", NULL
27273 };
27274
27275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27277 if (!SWIG_IsOK(res1)) {
27278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27279 }
27280 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27281 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27282 if (!SWIG_IsOK(res2)) {
27283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27284 }
27285 if (!argp2) {
27286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27287 }
27288 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27289 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27290 if (!SWIG_IsOK(res3)) {
27291 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27292 }
27293 if (!argp3) {
27294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27295 }
27296 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27300 wxPyEndAllowThreads(__tstate);
27301 if (PyErr_Occurred()) SWIG_fail;
27302 }
27303 {
27304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27305 }
27306 return resultobj;
27307 fail:
27308 return NULL;
27309 }
27310
27311
27312 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27313 PyObject *resultobj = 0;
27314 wxDateTime *arg1 = (wxDateTime *) 0 ;
27315 wxTimeSpan *arg2 = 0 ;
27316 wxDateTime *result = 0 ;
27317 void *argp1 = 0 ;
27318 int res1 = 0 ;
27319 void *argp2 = 0 ;
27320 int res2 = 0 ;
27321 PyObject * obj0 = 0 ;
27322 PyObject * obj1 = 0 ;
27323 char * kwnames[] = {
27324 (char *) "self",(char *) "diff", NULL
27325 };
27326
27327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27329 if (!SWIG_IsOK(res1)) {
27330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27331 }
27332 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27333 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27334 if (!SWIG_IsOK(res2)) {
27335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27336 }
27337 if (!argp2) {
27338 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27339 }
27340 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27341 {
27342 PyThreadState* __tstate = wxPyBeginAllowThreads();
27343 {
27344 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27345 result = (wxDateTime *) &_result_ref;
27346 }
27347 wxPyEndAllowThreads(__tstate);
27348 if (PyErr_Occurred()) SWIG_fail;
27349 }
27350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27351 return resultobj;
27352 fail:
27353 return NULL;
27354 }
27355
27356
27357 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27358 PyObject *resultobj = 0;
27359 wxDateTime *arg1 = (wxDateTime *) 0 ;
27360 wxDateSpan *arg2 = 0 ;
27361 wxDateTime *result = 0 ;
27362 void *argp1 = 0 ;
27363 int res1 = 0 ;
27364 void *argp2 = 0 ;
27365 int res2 = 0 ;
27366 PyObject * obj0 = 0 ;
27367 PyObject * obj1 = 0 ;
27368 char * kwnames[] = {
27369 (char *) "self",(char *) "diff", NULL
27370 };
27371
27372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27374 if (!SWIG_IsOK(res1)) {
27375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27376 }
27377 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27378 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27379 if (!SWIG_IsOK(res2)) {
27380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27381 }
27382 if (!argp2) {
27383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27384 }
27385 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 {
27389 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27390 result = (wxDateTime *) &_result_ref;
27391 }
27392 wxPyEndAllowThreads(__tstate);
27393 if (PyErr_Occurred()) SWIG_fail;
27394 }
27395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27396 return resultobj;
27397 fail:
27398 return NULL;
27399 }
27400
27401
27402 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27403 PyObject *resultobj = 0;
27404 wxDateTime *arg1 = (wxDateTime *) 0 ;
27405 wxTimeSpan *arg2 = 0 ;
27406 wxDateTime *result = 0 ;
27407 void *argp1 = 0 ;
27408 int res1 = 0 ;
27409 void *argp2 = 0 ;
27410 int res2 = 0 ;
27411 PyObject * obj0 = 0 ;
27412 PyObject * obj1 = 0 ;
27413 char * kwnames[] = {
27414 (char *) "self",(char *) "diff", NULL
27415 };
27416
27417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27419 if (!SWIG_IsOK(res1)) {
27420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27421 }
27422 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27423 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27424 if (!SWIG_IsOK(res2)) {
27425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27426 }
27427 if (!argp2) {
27428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27429 }
27430 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27431 {
27432 PyThreadState* __tstate = wxPyBeginAllowThreads();
27433 {
27434 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27435 result = (wxDateTime *) &_result_ref;
27436 }
27437 wxPyEndAllowThreads(__tstate);
27438 if (PyErr_Occurred()) SWIG_fail;
27439 }
27440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27441 return resultobj;
27442 fail:
27443 return NULL;
27444 }
27445
27446
27447 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27448 PyObject *resultobj = 0;
27449 wxDateTime *arg1 = (wxDateTime *) 0 ;
27450 wxDateSpan *arg2 = 0 ;
27451 wxDateTime *result = 0 ;
27452 void *argp1 = 0 ;
27453 int res1 = 0 ;
27454 void *argp2 = 0 ;
27455 int res2 = 0 ;
27456 PyObject * obj0 = 0 ;
27457 PyObject * obj1 = 0 ;
27458 char * kwnames[] = {
27459 (char *) "self",(char *) "diff", NULL
27460 };
27461
27462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27466 }
27467 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27468 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27469 if (!SWIG_IsOK(res2)) {
27470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27471 }
27472 if (!argp2) {
27473 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27474 }
27475 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 {
27479 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27480 result = (wxDateTime *) &_result_ref;
27481 }
27482 wxPyEndAllowThreads(__tstate);
27483 if (PyErr_Occurred()) SWIG_fail;
27484 }
27485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27486 return resultobj;
27487 fail:
27488 return NULL;
27489 }
27490
27491
27492 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27493 PyObject *resultobj = 0;
27494 wxDateTime *arg1 = (wxDateTime *) 0 ;
27495 wxDateTime *arg2 = 0 ;
27496 wxTimeSpan result;
27497 void *argp1 = 0 ;
27498 int res1 = 0 ;
27499 void *argp2 = 0 ;
27500 int res2 = 0 ;
27501 PyObject * obj0 = 0 ;
27502 PyObject * obj1 = 0 ;
27503 char * kwnames[] = {
27504 (char *) "self",(char *) "dt", NULL
27505 };
27506
27507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27509 if (!SWIG_IsOK(res1)) {
27510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27511 }
27512 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27513 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27514 if (!SWIG_IsOK(res2)) {
27515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27516 }
27517 if (!argp2) {
27518 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27519 }
27520 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27521 {
27522 PyThreadState* __tstate = wxPyBeginAllowThreads();
27523 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27524 wxPyEndAllowThreads(__tstate);
27525 if (PyErr_Occurred()) SWIG_fail;
27526 }
27527 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27528 return resultobj;
27529 fail:
27530 return NULL;
27531 }
27532
27533
27534 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27535 PyObject *resultobj = 0;
27536 wxDateTime *arg1 = (wxDateTime *) 0 ;
27537 wxTimeSpan *arg2 = 0 ;
27538 wxDateTime *result = 0 ;
27539 void *argp1 = 0 ;
27540 int res1 = 0 ;
27541 void *argp2 = 0 ;
27542 int res2 = 0 ;
27543
27544 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27546 if (!SWIG_IsOK(res1)) {
27547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27548 }
27549 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27550 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27551 if (!SWIG_IsOK(res2)) {
27552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27553 }
27554 if (!argp2) {
27555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27556 }
27557 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27558 {
27559 PyThreadState* __tstate = wxPyBeginAllowThreads();
27560 {
27561 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27562 result = (wxDateTime *) &_result_ref;
27563 }
27564 wxPyEndAllowThreads(__tstate);
27565 if (PyErr_Occurred()) SWIG_fail;
27566 }
27567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27568 return resultobj;
27569 fail:
27570 return NULL;
27571 }
27572
27573
27574 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27575 PyObject *resultobj = 0;
27576 wxDateTime *arg1 = (wxDateTime *) 0 ;
27577 wxDateSpan *arg2 = 0 ;
27578 wxDateTime *result = 0 ;
27579 void *argp1 = 0 ;
27580 int res1 = 0 ;
27581 void *argp2 = 0 ;
27582 int res2 = 0 ;
27583
27584 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27586 if (!SWIG_IsOK(res1)) {
27587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27588 }
27589 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27590 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27591 if (!SWIG_IsOK(res2)) {
27592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27593 }
27594 if (!argp2) {
27595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27596 }
27597 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 {
27601 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27602 result = (wxDateTime *) &_result_ref;
27603 }
27604 wxPyEndAllowThreads(__tstate);
27605 if (PyErr_Occurred()) SWIG_fail;
27606 }
27607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27608 return resultobj;
27609 fail:
27610 return NULL;
27611 }
27612
27613
27614 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27615 int argc;
27616 PyObject *argv[3];
27617
27618 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27619 --argc;
27620 if (argc == 2) {
27621 int _v = 0;
27622 {
27623 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27624 _v = SWIG_CheckState(res);
27625 }
27626 if (!_v) goto check_1;
27627 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27628 }
27629 check_1:
27630
27631 if (argc == 2) {
27632 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27633 }
27634
27635 fail:
27636 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27637 return NULL;
27638 }
27639
27640
27641 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27642 PyObject *resultobj = 0;
27643 wxDateTime *arg1 = (wxDateTime *) 0 ;
27644 wxTimeSpan *arg2 = 0 ;
27645 wxDateTime *result = 0 ;
27646 void *argp1 = 0 ;
27647 int res1 = 0 ;
27648 void *argp2 = 0 ;
27649 int res2 = 0 ;
27650
27651 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27653 if (!SWIG_IsOK(res1)) {
27654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27655 }
27656 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27657 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27658 if (!SWIG_IsOK(res2)) {
27659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27660 }
27661 if (!argp2) {
27662 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27663 }
27664 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27665 {
27666 PyThreadState* __tstate = wxPyBeginAllowThreads();
27667 {
27668 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27669 result = (wxDateTime *) &_result_ref;
27670 }
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27675 return resultobj;
27676 fail:
27677 return NULL;
27678 }
27679
27680
27681 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27682 PyObject *resultobj = 0;
27683 wxDateTime *arg1 = (wxDateTime *) 0 ;
27684 wxDateSpan *arg2 = 0 ;
27685 wxDateTime *result = 0 ;
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, SWIG_POINTER_DISOWN | 0 );
27693 if (!SWIG_IsOK(res1)) {
27694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27695 }
27696 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27697 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27698 if (!SWIG_IsOK(res2)) {
27699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27700 }
27701 if (!argp2) {
27702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27703 }
27704 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 {
27708 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27709 result = (wxDateTime *) &_result_ref;
27710 }
27711 wxPyEndAllowThreads(__tstate);
27712 if (PyErr_Occurred()) SWIG_fail;
27713 }
27714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27715 return resultobj;
27716 fail:
27717 return NULL;
27718 }
27719
27720
27721 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27722 int argc;
27723 PyObject *argv[3];
27724
27725 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27726 --argc;
27727 if (argc == 2) {
27728 int _v = 0;
27729 {
27730 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27731 _v = SWIG_CheckState(res);
27732 }
27733 if (!_v) goto check_1;
27734 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27735 }
27736 check_1:
27737
27738 if (argc == 2) {
27739 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27740 }
27741
27742 fail:
27743 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27744 return NULL;
27745 }
27746
27747
27748 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27749 PyObject *resultobj = 0;
27750 wxDateTime *arg1 = (wxDateTime *) 0 ;
27751 wxTimeSpan *arg2 = 0 ;
27752 wxDateTime result;
27753 void *argp1 = 0 ;
27754 int res1 = 0 ;
27755 void *argp2 = 0 ;
27756 int res2 = 0 ;
27757
27758 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27760 if (!SWIG_IsOK(res1)) {
27761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27762 }
27763 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27764 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27765 if (!SWIG_IsOK(res2)) {
27766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27767 }
27768 if (!argp2) {
27769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27770 }
27771 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27772 {
27773 PyThreadState* __tstate = wxPyBeginAllowThreads();
27774 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27775 wxPyEndAllowThreads(__tstate);
27776 if (PyErr_Occurred()) SWIG_fail;
27777 }
27778 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27779 return resultobj;
27780 fail:
27781 return NULL;
27782 }
27783
27784
27785 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27786 PyObject *resultobj = 0;
27787 wxDateTime *arg1 = (wxDateTime *) 0 ;
27788 wxDateSpan *arg2 = 0 ;
27789 wxDateTime result;
27790 void *argp1 = 0 ;
27791 int res1 = 0 ;
27792 void *argp2 = 0 ;
27793 int res2 = 0 ;
27794
27795 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27797 if (!SWIG_IsOK(res1)) {
27798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27799 }
27800 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27801 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27802 if (!SWIG_IsOK(res2)) {
27803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27804 }
27805 if (!argp2) {
27806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27807 }
27808 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27809 {
27810 PyThreadState* __tstate = wxPyBeginAllowThreads();
27811 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27812 wxPyEndAllowThreads(__tstate);
27813 if (PyErr_Occurred()) SWIG_fail;
27814 }
27815 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27816 return resultobj;
27817 fail:
27818 return NULL;
27819 }
27820
27821
27822 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27823 int argc;
27824 PyObject *argv[3];
27825
27826 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27827 --argc;
27828 if (argc == 2) {
27829 int _v = 0;
27830 {
27831 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27832 _v = SWIG_CheckState(res);
27833 }
27834 if (!_v) goto check_1;
27835 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27836 }
27837 check_1:
27838
27839 if (argc == 2) {
27840 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27841 }
27842
27843 fail:
27844 Py_INCREF(Py_NotImplemented);
27845 return Py_NotImplemented;
27846 }
27847
27848
27849 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27850 PyObject *resultobj = 0;
27851 wxDateTime *arg1 = (wxDateTime *) 0 ;
27852 wxDateTime *arg2 = 0 ;
27853 wxTimeSpan result;
27854 void *argp1 = 0 ;
27855 int res1 = 0 ;
27856 void *argp2 = 0 ;
27857 int res2 = 0 ;
27858
27859 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27861 if (!SWIG_IsOK(res1)) {
27862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27863 }
27864 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27865 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27866 if (!SWIG_IsOK(res2)) {
27867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27868 }
27869 if (!argp2) {
27870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27871 }
27872 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27887 PyObject *resultobj = 0;
27888 wxDateTime *arg1 = (wxDateTime *) 0 ;
27889 wxTimeSpan *arg2 = 0 ;
27890 wxDateTime result;
27891 void *argp1 = 0 ;
27892 int res1 = 0 ;
27893 void *argp2 = 0 ;
27894 int res2 = 0 ;
27895
27896 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27898 if (!SWIG_IsOK(res1)) {
27899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27900 }
27901 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27902 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27903 if (!SWIG_IsOK(res2)) {
27904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27905 }
27906 if (!argp2) {
27907 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27908 }
27909 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27910 {
27911 PyThreadState* __tstate = wxPyBeginAllowThreads();
27912 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27913 wxPyEndAllowThreads(__tstate);
27914 if (PyErr_Occurred()) SWIG_fail;
27915 }
27916 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27917 return resultobj;
27918 fail:
27919 return NULL;
27920 }
27921
27922
27923 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27924 PyObject *resultobj = 0;
27925 wxDateTime *arg1 = (wxDateTime *) 0 ;
27926 wxDateSpan *arg2 = 0 ;
27927 wxDateTime result;
27928 void *argp1 = 0 ;
27929 int res1 = 0 ;
27930 void *argp2 = 0 ;
27931 int res2 = 0 ;
27932
27933 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27935 if (!SWIG_IsOK(res1)) {
27936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27937 }
27938 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27939 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27940 if (!SWIG_IsOK(res2)) {
27941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27942 }
27943 if (!argp2) {
27944 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27945 }
27946 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27950 wxPyEndAllowThreads(__tstate);
27951 if (PyErr_Occurred()) SWIG_fail;
27952 }
27953 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27954 return resultobj;
27955 fail:
27956 return NULL;
27957 }
27958
27959
27960 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27961 int argc;
27962 PyObject *argv[3];
27963
27964 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27965 --argc;
27966 if (argc == 2) {
27967 int _v = 0;
27968 {
27969 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27970 _v = SWIG_CheckState(res);
27971 }
27972 if (!_v) goto check_1;
27973 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27974 }
27975 check_1:
27976
27977 if (argc == 2) {
27978 int _v = 0;
27979 {
27980 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27981 _v = SWIG_CheckState(res);
27982 }
27983 if (!_v) goto check_2;
27984 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27985 }
27986 check_2:
27987
27988 if (argc == 2) {
27989 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27990 }
27991
27992 fail:
27993 Py_INCREF(Py_NotImplemented);
27994 return Py_NotImplemented;
27995 }
27996
27997
27998 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27999 PyObject *resultobj = 0;
28000 wxDateTime *arg1 = (wxDateTime *) 0 ;
28001 wxDateTime *arg2 = (wxDateTime *) 0 ;
28002 bool result;
28003 void *argp1 = 0 ;
28004 int res1 = 0 ;
28005 void *argp2 = 0 ;
28006 int res2 = 0 ;
28007 PyObject * obj0 = 0 ;
28008 PyObject * obj1 = 0 ;
28009 char * kwnames[] = {
28010 (char *) "self",(char *) "other", NULL
28011 };
28012
28013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28015 if (!SWIG_IsOK(res1)) {
28016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28017 }
28018 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28019 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28020 if (!SWIG_IsOK(res2)) {
28021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28022 }
28023 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28024 {
28025 PyThreadState* __tstate = wxPyBeginAllowThreads();
28026 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
28027 wxPyEndAllowThreads(__tstate);
28028 if (PyErr_Occurred()) SWIG_fail;
28029 }
28030 {
28031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28032 }
28033 return resultobj;
28034 fail:
28035 return NULL;
28036 }
28037
28038
28039 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28040 PyObject *resultobj = 0;
28041 wxDateTime *arg1 = (wxDateTime *) 0 ;
28042 wxDateTime *arg2 = (wxDateTime *) 0 ;
28043 bool result;
28044 void *argp1 = 0 ;
28045 int res1 = 0 ;
28046 void *argp2 = 0 ;
28047 int res2 = 0 ;
28048 PyObject * obj0 = 0 ;
28049 PyObject * obj1 = 0 ;
28050 char * kwnames[] = {
28051 (char *) "self",(char *) "other", NULL
28052 };
28053
28054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28056 if (!SWIG_IsOK(res1)) {
28057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28058 }
28059 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28060 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28061 if (!SWIG_IsOK(res2)) {
28062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28063 }
28064 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28065 {
28066 PyThreadState* __tstate = wxPyBeginAllowThreads();
28067 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
28068 wxPyEndAllowThreads(__tstate);
28069 if (PyErr_Occurred()) SWIG_fail;
28070 }
28071 {
28072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28073 }
28074 return resultobj;
28075 fail:
28076 return NULL;
28077 }
28078
28079
28080 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28081 PyObject *resultobj = 0;
28082 wxDateTime *arg1 = (wxDateTime *) 0 ;
28083 wxDateTime *arg2 = (wxDateTime *) 0 ;
28084 bool result;
28085 void *argp1 = 0 ;
28086 int res1 = 0 ;
28087 void *argp2 = 0 ;
28088 int res2 = 0 ;
28089 PyObject * obj0 = 0 ;
28090 PyObject * obj1 = 0 ;
28091 char * kwnames[] = {
28092 (char *) "self",(char *) "other", NULL
28093 };
28094
28095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28097 if (!SWIG_IsOK(res1)) {
28098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28099 }
28100 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28101 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28102 if (!SWIG_IsOK(res2)) {
28103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28104 }
28105 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 {
28113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28114 }
28115 return resultobj;
28116 fail:
28117 return NULL;
28118 }
28119
28120
28121 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28122 PyObject *resultobj = 0;
28123 wxDateTime *arg1 = (wxDateTime *) 0 ;
28124 wxDateTime *arg2 = (wxDateTime *) 0 ;
28125 bool result;
28126 void *argp1 = 0 ;
28127 int res1 = 0 ;
28128 void *argp2 = 0 ;
28129 int res2 = 0 ;
28130 PyObject * obj0 = 0 ;
28131 PyObject * obj1 = 0 ;
28132 char * kwnames[] = {
28133 (char *) "self",(char *) "other", NULL
28134 };
28135
28136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28138 if (!SWIG_IsOK(res1)) {
28139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28140 }
28141 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28143 if (!SWIG_IsOK(res2)) {
28144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28145 }
28146 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28147 {
28148 PyThreadState* __tstate = wxPyBeginAllowThreads();
28149 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 {
28154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28155 }
28156 return resultobj;
28157 fail:
28158 return NULL;
28159 }
28160
28161
28162 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28163 PyObject *resultobj = 0;
28164 wxDateTime *arg1 = (wxDateTime *) 0 ;
28165 wxDateTime *arg2 = (wxDateTime *) 0 ;
28166 bool result;
28167 void *argp1 = 0 ;
28168 int res1 = 0 ;
28169 void *argp2 = 0 ;
28170 int res2 = 0 ;
28171 PyObject * obj0 = 0 ;
28172 PyObject * obj1 = 0 ;
28173 char * kwnames[] = {
28174 (char *) "self",(char *) "other", NULL
28175 };
28176
28177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28179 if (!SWIG_IsOK(res1)) {
28180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28181 }
28182 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28184 if (!SWIG_IsOK(res2)) {
28185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28186 }
28187 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28188 {
28189 PyThreadState* __tstate = wxPyBeginAllowThreads();
28190 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28191 wxPyEndAllowThreads(__tstate);
28192 if (PyErr_Occurred()) SWIG_fail;
28193 }
28194 {
28195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28196 }
28197 return resultobj;
28198 fail:
28199 return NULL;
28200 }
28201
28202
28203 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28204 PyObject *resultobj = 0;
28205 wxDateTime *arg1 = (wxDateTime *) 0 ;
28206 wxDateTime *arg2 = (wxDateTime *) 0 ;
28207 bool result;
28208 void *argp1 = 0 ;
28209 int res1 = 0 ;
28210 void *argp2 = 0 ;
28211 int res2 = 0 ;
28212 PyObject * obj0 = 0 ;
28213 PyObject * obj1 = 0 ;
28214 char * kwnames[] = {
28215 (char *) "self",(char *) "other", NULL
28216 };
28217
28218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28220 if (!SWIG_IsOK(res1)) {
28221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28222 }
28223 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28225 if (!SWIG_IsOK(res2)) {
28226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28227 }
28228 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 {
28236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28237 }
28238 return resultobj;
28239 fail:
28240 return NULL;
28241 }
28242
28243
28244 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28245 PyObject *resultobj = 0;
28246 wxDateTime *arg1 = (wxDateTime *) 0 ;
28247 wxString *arg2 = 0 ;
28248 int result;
28249 void *argp1 = 0 ;
28250 int res1 = 0 ;
28251 bool temp2 = false ;
28252 PyObject * obj0 = 0 ;
28253 PyObject * obj1 = 0 ;
28254 char * kwnames[] = {
28255 (char *) "self",(char *) "date", NULL
28256 };
28257
28258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28260 if (!SWIG_IsOK(res1)) {
28261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28262 }
28263 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28264 {
28265 arg2 = wxString_in_helper(obj1);
28266 if (arg2 == NULL) SWIG_fail;
28267 temp2 = true;
28268 }
28269 {
28270 PyThreadState* __tstate = wxPyBeginAllowThreads();
28271 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28272 wxPyEndAllowThreads(__tstate);
28273 if (PyErr_Occurred()) SWIG_fail;
28274 }
28275 resultobj = SWIG_From_int(static_cast< int >(result));
28276 {
28277 if (temp2)
28278 delete arg2;
28279 }
28280 return resultobj;
28281 fail:
28282 {
28283 if (temp2)
28284 delete arg2;
28285 }
28286 return NULL;
28287 }
28288
28289
28290 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28291 PyObject *resultobj = 0;
28292 wxDateTime *arg1 = (wxDateTime *) 0 ;
28293 wxString *arg2 = 0 ;
28294 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28295 wxString *arg3 = (wxString *) &arg3_defvalue ;
28296 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28297 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28298 int result;
28299 void *argp1 = 0 ;
28300 int res1 = 0 ;
28301 bool temp2 = false ;
28302 bool temp3 = false ;
28303 void *argp4 = 0 ;
28304 int res4 = 0 ;
28305 PyObject * obj0 = 0 ;
28306 PyObject * obj1 = 0 ;
28307 PyObject * obj2 = 0 ;
28308 PyObject * obj3 = 0 ;
28309 char * kwnames[] = {
28310 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28311 };
28312
28313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28315 if (!SWIG_IsOK(res1)) {
28316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28317 }
28318 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28319 {
28320 arg2 = wxString_in_helper(obj1);
28321 if (arg2 == NULL) SWIG_fail;
28322 temp2 = true;
28323 }
28324 if (obj2) {
28325 {
28326 arg3 = wxString_in_helper(obj2);
28327 if (arg3 == NULL) SWIG_fail;
28328 temp3 = true;
28329 }
28330 }
28331 if (obj3) {
28332 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28333 if (!SWIG_IsOK(res4)) {
28334 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28335 }
28336 if (!argp4) {
28337 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28338 }
28339 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28340 }
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 resultobj = SWIG_From_int(static_cast< int >(result));
28348 {
28349 if (temp2)
28350 delete arg2;
28351 }
28352 {
28353 if (temp3)
28354 delete arg3;
28355 }
28356 return resultobj;
28357 fail:
28358 {
28359 if (temp2)
28360 delete arg2;
28361 }
28362 {
28363 if (temp3)
28364 delete arg3;
28365 }
28366 return NULL;
28367 }
28368
28369
28370 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28371 PyObject *resultobj = 0;
28372 wxDateTime *arg1 = (wxDateTime *) 0 ;
28373 wxString *arg2 = 0 ;
28374 int result;
28375 void *argp1 = 0 ;
28376 int res1 = 0 ;
28377 bool temp2 = false ;
28378 PyObject * obj0 = 0 ;
28379 PyObject * obj1 = 0 ;
28380 char * kwnames[] = {
28381 (char *) "self",(char *) "datetime", NULL
28382 };
28383
28384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28386 if (!SWIG_IsOK(res1)) {
28387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28388 }
28389 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28390 {
28391 arg2 = wxString_in_helper(obj1);
28392 if (arg2 == NULL) SWIG_fail;
28393 temp2 = true;
28394 }
28395 {
28396 PyThreadState* __tstate = wxPyBeginAllowThreads();
28397 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 resultobj = SWIG_From_int(static_cast< int >(result));
28402 {
28403 if (temp2)
28404 delete arg2;
28405 }
28406 return resultobj;
28407 fail:
28408 {
28409 if (temp2)
28410 delete arg2;
28411 }
28412 return NULL;
28413 }
28414
28415
28416 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28417 PyObject *resultobj = 0;
28418 wxDateTime *arg1 = (wxDateTime *) 0 ;
28419 wxString *arg2 = 0 ;
28420 int result;
28421 void *argp1 = 0 ;
28422 int res1 = 0 ;
28423 bool temp2 = false ;
28424 PyObject * obj0 = 0 ;
28425 PyObject * obj1 = 0 ;
28426 char * kwnames[] = {
28427 (char *) "self",(char *) "date", NULL
28428 };
28429
28430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28432 if (!SWIG_IsOK(res1)) {
28433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28434 }
28435 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28436 {
28437 arg2 = wxString_in_helper(obj1);
28438 if (arg2 == NULL) SWIG_fail;
28439 temp2 = true;
28440 }
28441 {
28442 PyThreadState* __tstate = wxPyBeginAllowThreads();
28443 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28444 wxPyEndAllowThreads(__tstate);
28445 if (PyErr_Occurred()) SWIG_fail;
28446 }
28447 resultobj = SWIG_From_int(static_cast< int >(result));
28448 {
28449 if (temp2)
28450 delete arg2;
28451 }
28452 return resultobj;
28453 fail:
28454 {
28455 if (temp2)
28456 delete arg2;
28457 }
28458 return NULL;
28459 }
28460
28461
28462 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28463 PyObject *resultobj = 0;
28464 wxDateTime *arg1 = (wxDateTime *) 0 ;
28465 wxString *arg2 = 0 ;
28466 int result;
28467 void *argp1 = 0 ;
28468 int res1 = 0 ;
28469 bool temp2 = false ;
28470 PyObject * obj0 = 0 ;
28471 PyObject * obj1 = 0 ;
28472 char * kwnames[] = {
28473 (char *) "self",(char *) "time", NULL
28474 };
28475
28476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28478 if (!SWIG_IsOK(res1)) {
28479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28480 }
28481 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28482 {
28483 arg2 = wxString_in_helper(obj1);
28484 if (arg2 == NULL) SWIG_fail;
28485 temp2 = true;
28486 }
28487 {
28488 PyThreadState* __tstate = wxPyBeginAllowThreads();
28489 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28490 wxPyEndAllowThreads(__tstate);
28491 if (PyErr_Occurred()) SWIG_fail;
28492 }
28493 resultobj = SWIG_From_int(static_cast< int >(result));
28494 {
28495 if (temp2)
28496 delete arg2;
28497 }
28498 return resultobj;
28499 fail:
28500 {
28501 if (temp2)
28502 delete arg2;
28503 }
28504 return NULL;
28505 }
28506
28507
28508 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28509 PyObject *resultobj = 0;
28510 wxDateTime *arg1 = (wxDateTime *) 0 ;
28511 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28512 wxString *arg2 = (wxString *) &arg2_defvalue ;
28513 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28514 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28515 wxString result;
28516 void *argp1 = 0 ;
28517 int res1 = 0 ;
28518 bool temp2 = false ;
28519 bool temp3 = false ;
28520 PyObject * obj0 = 0 ;
28521 PyObject * obj1 = 0 ;
28522 PyObject * obj2 = 0 ;
28523 char * kwnames[] = {
28524 (char *) "self",(char *) "format",(char *) "tz", NULL
28525 };
28526
28527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28529 if (!SWIG_IsOK(res1)) {
28530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28531 }
28532 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28533 if (obj1) {
28534 {
28535 arg2 = wxString_in_helper(obj1);
28536 if (arg2 == NULL) SWIG_fail;
28537 temp2 = true;
28538 }
28539 }
28540 if (obj2) {
28541 {
28542 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28543 temp3 = true;
28544 }
28545 }
28546 {
28547 PyThreadState* __tstate = wxPyBeginAllowThreads();
28548 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28549 wxPyEndAllowThreads(__tstate);
28550 if (PyErr_Occurred()) SWIG_fail;
28551 }
28552 {
28553 #if wxUSE_UNICODE
28554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28555 #else
28556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28557 #endif
28558 }
28559 {
28560 if (temp2)
28561 delete arg2;
28562 }
28563 {
28564 if (temp3) delete arg3;
28565 }
28566 return resultobj;
28567 fail:
28568 {
28569 if (temp2)
28570 delete arg2;
28571 }
28572 {
28573 if (temp3) delete arg3;
28574 }
28575 return NULL;
28576 }
28577
28578
28579 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28580 PyObject *resultobj = 0;
28581 wxDateTime *arg1 = (wxDateTime *) 0 ;
28582 wxString result;
28583 void *argp1 = 0 ;
28584 int res1 = 0 ;
28585 PyObject *swig_obj[1] ;
28586
28587 if (!args) SWIG_fail;
28588 swig_obj[0] = args;
28589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28590 if (!SWIG_IsOK(res1)) {
28591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28592 }
28593 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28594 {
28595 PyThreadState* __tstate = wxPyBeginAllowThreads();
28596 result = ((wxDateTime const *)arg1)->FormatDate();
28597 wxPyEndAllowThreads(__tstate);
28598 if (PyErr_Occurred()) SWIG_fail;
28599 }
28600 {
28601 #if wxUSE_UNICODE
28602 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28603 #else
28604 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28605 #endif
28606 }
28607 return resultobj;
28608 fail:
28609 return NULL;
28610 }
28611
28612
28613 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28614 PyObject *resultobj = 0;
28615 wxDateTime *arg1 = (wxDateTime *) 0 ;
28616 wxString result;
28617 void *argp1 = 0 ;
28618 int res1 = 0 ;
28619 PyObject *swig_obj[1] ;
28620
28621 if (!args) SWIG_fail;
28622 swig_obj[0] = args;
28623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28624 if (!SWIG_IsOK(res1)) {
28625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28626 }
28627 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28628 {
28629 PyThreadState* __tstate = wxPyBeginAllowThreads();
28630 result = ((wxDateTime const *)arg1)->FormatTime();
28631 wxPyEndAllowThreads(__tstate);
28632 if (PyErr_Occurred()) SWIG_fail;
28633 }
28634 {
28635 #if wxUSE_UNICODE
28636 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28637 #else
28638 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28639 #endif
28640 }
28641 return resultobj;
28642 fail:
28643 return NULL;
28644 }
28645
28646
28647 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28648 PyObject *resultobj = 0;
28649 wxDateTime *arg1 = (wxDateTime *) 0 ;
28650 wxString result;
28651 void *argp1 = 0 ;
28652 int res1 = 0 ;
28653 PyObject *swig_obj[1] ;
28654
28655 if (!args) SWIG_fail;
28656 swig_obj[0] = args;
28657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28658 if (!SWIG_IsOK(res1)) {
28659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28660 }
28661 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28662 {
28663 PyThreadState* __tstate = wxPyBeginAllowThreads();
28664 result = ((wxDateTime const *)arg1)->FormatISODate();
28665 wxPyEndAllowThreads(__tstate);
28666 if (PyErr_Occurred()) SWIG_fail;
28667 }
28668 {
28669 #if wxUSE_UNICODE
28670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28671 #else
28672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28673 #endif
28674 }
28675 return resultobj;
28676 fail:
28677 return NULL;
28678 }
28679
28680
28681 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28682 PyObject *resultobj = 0;
28683 wxDateTime *arg1 = (wxDateTime *) 0 ;
28684 wxString result;
28685 void *argp1 = 0 ;
28686 int res1 = 0 ;
28687 PyObject *swig_obj[1] ;
28688
28689 if (!args) SWIG_fail;
28690 swig_obj[0] = args;
28691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28692 if (!SWIG_IsOK(res1)) {
28693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28694 }
28695 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 result = ((wxDateTime const *)arg1)->FormatISOTime();
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 {
28703 #if wxUSE_UNICODE
28704 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28705 #else
28706 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28707 #endif
28708 }
28709 return resultobj;
28710 fail:
28711 return NULL;
28712 }
28713
28714
28715 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28716 PyObject *obj;
28717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28718 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28719 return SWIG_Py_Void();
28720 }
28721
28722 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28723 return SWIG_Python_InitShadowInstance(args);
28724 }
28725
28726 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28727 PyObject *resultobj = 0;
28728 long arg1 ;
28729 wxTimeSpan result;
28730 long val1 ;
28731 int ecode1 = 0 ;
28732 PyObject * obj0 = 0 ;
28733 char * kwnames[] = {
28734 (char *) "ms", NULL
28735 };
28736
28737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28738 ecode1 = SWIG_AsVal_long(obj0, &val1);
28739 if (!SWIG_IsOK(ecode1)) {
28740 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28741 }
28742 arg1 = static_cast< long >(val1);
28743 {
28744 PyThreadState* __tstate = wxPyBeginAllowThreads();
28745 result = wxTimeSpan::Milliseconds(arg1);
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28750 return resultobj;
28751 fail:
28752 return NULL;
28753 }
28754
28755
28756 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28757 PyObject *resultobj = 0;
28758 wxTimeSpan result;
28759
28760 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28761 {
28762 PyThreadState* __tstate = wxPyBeginAllowThreads();
28763 result = wxTimeSpan::Millisecond();
28764 wxPyEndAllowThreads(__tstate);
28765 if (PyErr_Occurred()) SWIG_fail;
28766 }
28767 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28768 return resultobj;
28769 fail:
28770 return NULL;
28771 }
28772
28773
28774 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28775 PyObject *resultobj = 0;
28776 long arg1 ;
28777 wxTimeSpan result;
28778 long val1 ;
28779 int ecode1 = 0 ;
28780 PyObject * obj0 = 0 ;
28781 char * kwnames[] = {
28782 (char *) "sec", NULL
28783 };
28784
28785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28786 ecode1 = SWIG_AsVal_long(obj0, &val1);
28787 if (!SWIG_IsOK(ecode1)) {
28788 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28789 }
28790 arg1 = static_cast< long >(val1);
28791 {
28792 PyThreadState* __tstate = wxPyBeginAllowThreads();
28793 result = wxTimeSpan::Seconds(arg1);
28794 wxPyEndAllowThreads(__tstate);
28795 if (PyErr_Occurred()) SWIG_fail;
28796 }
28797 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28798 return resultobj;
28799 fail:
28800 return NULL;
28801 }
28802
28803
28804 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28805 PyObject *resultobj = 0;
28806 wxTimeSpan result;
28807
28808 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28809 {
28810 PyThreadState* __tstate = wxPyBeginAllowThreads();
28811 result = wxTimeSpan::Second();
28812 wxPyEndAllowThreads(__tstate);
28813 if (PyErr_Occurred()) SWIG_fail;
28814 }
28815 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28816 return resultobj;
28817 fail:
28818 return NULL;
28819 }
28820
28821
28822 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28823 PyObject *resultobj = 0;
28824 long arg1 ;
28825 wxTimeSpan result;
28826 long val1 ;
28827 int ecode1 = 0 ;
28828 PyObject * obj0 = 0 ;
28829 char * kwnames[] = {
28830 (char *) "min", NULL
28831 };
28832
28833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28834 ecode1 = SWIG_AsVal_long(obj0, &val1);
28835 if (!SWIG_IsOK(ecode1)) {
28836 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28837 }
28838 arg1 = static_cast< long >(val1);
28839 {
28840 PyThreadState* __tstate = wxPyBeginAllowThreads();
28841 result = wxTimeSpan::Minutes(arg1);
28842 wxPyEndAllowThreads(__tstate);
28843 if (PyErr_Occurred()) SWIG_fail;
28844 }
28845 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28846 return resultobj;
28847 fail:
28848 return NULL;
28849 }
28850
28851
28852 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28853 PyObject *resultobj = 0;
28854 wxTimeSpan result;
28855
28856 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28857 {
28858 PyThreadState* __tstate = wxPyBeginAllowThreads();
28859 result = wxTimeSpan::Minute();
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28864 return resultobj;
28865 fail:
28866 return NULL;
28867 }
28868
28869
28870 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28871 PyObject *resultobj = 0;
28872 long arg1 ;
28873 wxTimeSpan result;
28874 long val1 ;
28875 int ecode1 = 0 ;
28876 PyObject * obj0 = 0 ;
28877 char * kwnames[] = {
28878 (char *) "hours", NULL
28879 };
28880
28881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28882 ecode1 = SWIG_AsVal_long(obj0, &val1);
28883 if (!SWIG_IsOK(ecode1)) {
28884 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28885 }
28886 arg1 = static_cast< long >(val1);
28887 {
28888 PyThreadState* __tstate = wxPyBeginAllowThreads();
28889 result = wxTimeSpan::Hours(arg1);
28890 wxPyEndAllowThreads(__tstate);
28891 if (PyErr_Occurred()) SWIG_fail;
28892 }
28893 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28894 return resultobj;
28895 fail:
28896 return NULL;
28897 }
28898
28899
28900 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28901 PyObject *resultobj = 0;
28902 wxTimeSpan result;
28903
28904 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28905 {
28906 PyThreadState* __tstate = wxPyBeginAllowThreads();
28907 result = wxTimeSpan::Hour();
28908 wxPyEndAllowThreads(__tstate);
28909 if (PyErr_Occurred()) SWIG_fail;
28910 }
28911 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28912 return resultobj;
28913 fail:
28914 return NULL;
28915 }
28916
28917
28918 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28919 PyObject *resultobj = 0;
28920 long arg1 ;
28921 wxTimeSpan result;
28922 long val1 ;
28923 int ecode1 = 0 ;
28924 PyObject * obj0 = 0 ;
28925 char * kwnames[] = {
28926 (char *) "days", NULL
28927 };
28928
28929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28930 ecode1 = SWIG_AsVal_long(obj0, &val1);
28931 if (!SWIG_IsOK(ecode1)) {
28932 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28933 }
28934 arg1 = static_cast< long >(val1);
28935 {
28936 PyThreadState* __tstate = wxPyBeginAllowThreads();
28937 result = wxTimeSpan::Days(arg1);
28938 wxPyEndAllowThreads(__tstate);
28939 if (PyErr_Occurred()) SWIG_fail;
28940 }
28941 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28942 return resultobj;
28943 fail:
28944 return NULL;
28945 }
28946
28947
28948 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28949 PyObject *resultobj = 0;
28950 wxTimeSpan result;
28951
28952 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28953 {
28954 PyThreadState* __tstate = wxPyBeginAllowThreads();
28955 result = wxTimeSpan::Day();
28956 wxPyEndAllowThreads(__tstate);
28957 if (PyErr_Occurred()) SWIG_fail;
28958 }
28959 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28960 return resultobj;
28961 fail:
28962 return NULL;
28963 }
28964
28965
28966 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28967 PyObject *resultobj = 0;
28968 long arg1 ;
28969 wxTimeSpan result;
28970 long val1 ;
28971 int ecode1 = 0 ;
28972 PyObject * obj0 = 0 ;
28973 char * kwnames[] = {
28974 (char *) "days", NULL
28975 };
28976
28977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28978 ecode1 = SWIG_AsVal_long(obj0, &val1);
28979 if (!SWIG_IsOK(ecode1)) {
28980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28981 }
28982 arg1 = static_cast< long >(val1);
28983 {
28984 PyThreadState* __tstate = wxPyBeginAllowThreads();
28985 result = wxTimeSpan::Weeks(arg1);
28986 wxPyEndAllowThreads(__tstate);
28987 if (PyErr_Occurred()) SWIG_fail;
28988 }
28989 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28990 return resultobj;
28991 fail:
28992 return NULL;
28993 }
28994
28995
28996 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28997 PyObject *resultobj = 0;
28998 wxTimeSpan result;
28999
29000 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
29001 {
29002 PyThreadState* __tstate = wxPyBeginAllowThreads();
29003 result = wxTimeSpan::Week();
29004 wxPyEndAllowThreads(__tstate);
29005 if (PyErr_Occurred()) SWIG_fail;
29006 }
29007 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29008 return resultobj;
29009 fail:
29010 return NULL;
29011 }
29012
29013
29014 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29015 PyObject *resultobj = 0;
29016 long arg1 = (long) 0 ;
29017 long arg2 = (long) 0 ;
29018 long arg3 = (long) 0 ;
29019 long arg4 = (long) 0 ;
29020 wxTimeSpan *result = 0 ;
29021 long val1 ;
29022 int ecode1 = 0 ;
29023 long val2 ;
29024 int ecode2 = 0 ;
29025 long val3 ;
29026 int ecode3 = 0 ;
29027 long val4 ;
29028 int ecode4 = 0 ;
29029 PyObject * obj0 = 0 ;
29030 PyObject * obj1 = 0 ;
29031 PyObject * obj2 = 0 ;
29032 PyObject * obj3 = 0 ;
29033 char * kwnames[] = {
29034 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
29035 };
29036
29037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29038 if (obj0) {
29039 ecode1 = SWIG_AsVal_long(obj0, &val1);
29040 if (!SWIG_IsOK(ecode1)) {
29041 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
29042 }
29043 arg1 = static_cast< long >(val1);
29044 }
29045 if (obj1) {
29046 ecode2 = SWIG_AsVal_long(obj1, &val2);
29047 if (!SWIG_IsOK(ecode2)) {
29048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
29049 }
29050 arg2 = static_cast< long >(val2);
29051 }
29052 if (obj2) {
29053 ecode3 = SWIG_AsVal_long(obj2, &val3);
29054 if (!SWIG_IsOK(ecode3)) {
29055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
29056 }
29057 arg3 = static_cast< long >(val3);
29058 }
29059 if (obj3) {
29060 ecode4 = SWIG_AsVal_long(obj3, &val4);
29061 if (!SWIG_IsOK(ecode4)) {
29062 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
29063 }
29064 arg4 = static_cast< long >(val4);
29065 }
29066 {
29067 PyThreadState* __tstate = wxPyBeginAllowThreads();
29068 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29080 PyObject *resultobj = 0;
29081 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29082 void *argp1 = 0 ;
29083 int res1 = 0 ;
29084 PyObject *swig_obj[1] ;
29085
29086 if (!args) SWIG_fail;
29087 swig_obj[0] = args;
29088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29089 if (!SWIG_IsOK(res1)) {
29090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29091 }
29092 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29093 {
29094 PyThreadState* __tstate = wxPyBeginAllowThreads();
29095 delete arg1;
29096
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 resultobj = SWIG_Py_Void();
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29108 PyObject *resultobj = 0;
29109 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29110 wxTimeSpan *arg2 = 0 ;
29111 wxTimeSpan *result = 0 ;
29112 void *argp1 = 0 ;
29113 int res1 = 0 ;
29114 void *argp2 = 0 ;
29115 int res2 = 0 ;
29116 PyObject * obj0 = 0 ;
29117 PyObject * obj1 = 0 ;
29118 char * kwnames[] = {
29119 (char *) "self",(char *) "diff", NULL
29120 };
29121
29122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29124 if (!SWIG_IsOK(res1)) {
29125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29126 }
29127 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29129 if (!SWIG_IsOK(res2)) {
29130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29131 }
29132 if (!argp2) {
29133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29134 }
29135 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29136 {
29137 PyThreadState* __tstate = wxPyBeginAllowThreads();
29138 {
29139 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29140 result = (wxTimeSpan *) &_result_ref;
29141 }
29142 wxPyEndAllowThreads(__tstate);
29143 if (PyErr_Occurred()) SWIG_fail;
29144 }
29145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29146 return resultobj;
29147 fail:
29148 return NULL;
29149 }
29150
29151
29152 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29153 PyObject *resultobj = 0;
29154 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29155 wxTimeSpan *arg2 = 0 ;
29156 wxTimeSpan *result = 0 ;
29157 void *argp1 = 0 ;
29158 int res1 = 0 ;
29159 void *argp2 = 0 ;
29160 int res2 = 0 ;
29161 PyObject * obj0 = 0 ;
29162 PyObject * obj1 = 0 ;
29163 char * kwnames[] = {
29164 (char *) "self",(char *) "diff", NULL
29165 };
29166
29167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29169 if (!SWIG_IsOK(res1)) {
29170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29171 }
29172 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29173 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29174 if (!SWIG_IsOK(res2)) {
29175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29176 }
29177 if (!argp2) {
29178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29179 }
29180 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29181 {
29182 PyThreadState* __tstate = wxPyBeginAllowThreads();
29183 {
29184 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29185 result = (wxTimeSpan *) &_result_ref;
29186 }
29187 wxPyEndAllowThreads(__tstate);
29188 if (PyErr_Occurred()) SWIG_fail;
29189 }
29190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29191 return resultobj;
29192 fail:
29193 return NULL;
29194 }
29195
29196
29197 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29198 PyObject *resultobj = 0;
29199 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29200 int arg2 ;
29201 wxTimeSpan *result = 0 ;
29202 void *argp1 = 0 ;
29203 int res1 = 0 ;
29204 int val2 ;
29205 int ecode2 = 0 ;
29206 PyObject * obj0 = 0 ;
29207 PyObject * obj1 = 0 ;
29208 char * kwnames[] = {
29209 (char *) "self",(char *) "n", NULL
29210 };
29211
29212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29214 if (!SWIG_IsOK(res1)) {
29215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29216 }
29217 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29218 ecode2 = SWIG_AsVal_int(obj1, &val2);
29219 if (!SWIG_IsOK(ecode2)) {
29220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29221 }
29222 arg2 = static_cast< int >(val2);
29223 {
29224 PyThreadState* __tstate = wxPyBeginAllowThreads();
29225 {
29226 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29227 result = (wxTimeSpan *) &_result_ref;
29228 }
29229 wxPyEndAllowThreads(__tstate);
29230 if (PyErr_Occurred()) SWIG_fail;
29231 }
29232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29233 return resultobj;
29234 fail:
29235 return NULL;
29236 }
29237
29238
29239 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29240 PyObject *resultobj = 0;
29241 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29242 wxTimeSpan *result = 0 ;
29243 void *argp1 = 0 ;
29244 int res1 = 0 ;
29245 PyObject *swig_obj[1] ;
29246
29247 if (!args) SWIG_fail;
29248 swig_obj[0] = args;
29249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29250 if (!SWIG_IsOK(res1)) {
29251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29252 }
29253 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29254 {
29255 PyThreadState* __tstate = wxPyBeginAllowThreads();
29256 {
29257 wxTimeSpan &_result_ref = (arg1)->Neg();
29258 result = (wxTimeSpan *) &_result_ref;
29259 }
29260 wxPyEndAllowThreads(__tstate);
29261 if (PyErr_Occurred()) SWIG_fail;
29262 }
29263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29264 return resultobj;
29265 fail:
29266 return NULL;
29267 }
29268
29269
29270 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29271 PyObject *resultobj = 0;
29272 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29273 wxTimeSpan result;
29274 void *argp1 = 0 ;
29275 int res1 = 0 ;
29276 PyObject *swig_obj[1] ;
29277
29278 if (!args) SWIG_fail;
29279 swig_obj[0] = args;
29280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29281 if (!SWIG_IsOK(res1)) {
29282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29283 }
29284 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 result = ((wxTimeSpan const *)arg1)->Abs();
29288 wxPyEndAllowThreads(__tstate);
29289 if (PyErr_Occurred()) SWIG_fail;
29290 }
29291 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29292 return resultobj;
29293 fail:
29294 return NULL;
29295 }
29296
29297
29298 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29299 PyObject *resultobj = 0;
29300 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29301 wxTimeSpan *arg2 = 0 ;
29302 wxTimeSpan *result = 0 ;
29303 void *argp1 = 0 ;
29304 int res1 = 0 ;
29305 void *argp2 = 0 ;
29306 int res2 = 0 ;
29307 PyObject * obj0 = 0 ;
29308 PyObject * obj1 = 0 ;
29309 char * kwnames[] = {
29310 (char *) "self",(char *) "diff", NULL
29311 };
29312
29313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29315 if (!SWIG_IsOK(res1)) {
29316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29317 }
29318 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29319 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29320 if (!SWIG_IsOK(res2)) {
29321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29322 }
29323 if (!argp2) {
29324 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29325 }
29326 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29327 {
29328 PyThreadState* __tstate = wxPyBeginAllowThreads();
29329 {
29330 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29331 result = (wxTimeSpan *) &_result_ref;
29332 }
29333 wxPyEndAllowThreads(__tstate);
29334 if (PyErr_Occurred()) SWIG_fail;
29335 }
29336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29337 return resultobj;
29338 fail:
29339 return NULL;
29340 }
29341
29342
29343 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29344 PyObject *resultobj = 0;
29345 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29346 wxTimeSpan *arg2 = 0 ;
29347 wxTimeSpan *result = 0 ;
29348 void *argp1 = 0 ;
29349 int res1 = 0 ;
29350 void *argp2 = 0 ;
29351 int res2 = 0 ;
29352 PyObject * obj0 = 0 ;
29353 PyObject * obj1 = 0 ;
29354 char * kwnames[] = {
29355 (char *) "self",(char *) "diff", NULL
29356 };
29357
29358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29360 if (!SWIG_IsOK(res1)) {
29361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29362 }
29363 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29365 if (!SWIG_IsOK(res2)) {
29366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29367 }
29368 if (!argp2) {
29369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29370 }
29371 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29372 {
29373 PyThreadState* __tstate = wxPyBeginAllowThreads();
29374 {
29375 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29376 result = (wxTimeSpan *) &_result_ref;
29377 }
29378 wxPyEndAllowThreads(__tstate);
29379 if (PyErr_Occurred()) SWIG_fail;
29380 }
29381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29382 return resultobj;
29383 fail:
29384 return NULL;
29385 }
29386
29387
29388 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29389 PyObject *resultobj = 0;
29390 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29391 int arg2 ;
29392 wxTimeSpan *result = 0 ;
29393 void *argp1 = 0 ;
29394 int res1 = 0 ;
29395 int val2 ;
29396 int ecode2 = 0 ;
29397 PyObject * obj0 = 0 ;
29398 PyObject * obj1 = 0 ;
29399 char * kwnames[] = {
29400 (char *) "self",(char *) "n", NULL
29401 };
29402
29403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29405 if (!SWIG_IsOK(res1)) {
29406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29407 }
29408 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29409 ecode2 = SWIG_AsVal_int(obj1, &val2);
29410 if (!SWIG_IsOK(ecode2)) {
29411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29412 }
29413 arg2 = static_cast< int >(val2);
29414 {
29415 PyThreadState* __tstate = wxPyBeginAllowThreads();
29416 {
29417 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29418 result = (wxTimeSpan *) &_result_ref;
29419 }
29420 wxPyEndAllowThreads(__tstate);
29421 if (PyErr_Occurred()) SWIG_fail;
29422 }
29423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29431 PyObject *resultobj = 0;
29432 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29433 wxTimeSpan *result = 0 ;
29434 void *argp1 = 0 ;
29435 int res1 = 0 ;
29436 PyObject *swig_obj[1] ;
29437
29438 if (!args) SWIG_fail;
29439 swig_obj[0] = args;
29440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29441 if (!SWIG_IsOK(res1)) {
29442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29443 }
29444 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29445 {
29446 PyThreadState* __tstate = wxPyBeginAllowThreads();
29447 {
29448 wxTimeSpan &_result_ref = (arg1)->operator -();
29449 result = (wxTimeSpan *) &_result_ref;
29450 }
29451 wxPyEndAllowThreads(__tstate);
29452 if (PyErr_Occurred()) SWIG_fail;
29453 }
29454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29455 return resultobj;
29456 fail:
29457 return NULL;
29458 }
29459
29460
29461 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29462 PyObject *resultobj = 0;
29463 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29464 wxTimeSpan *arg2 = 0 ;
29465 wxTimeSpan result;
29466 void *argp1 = 0 ;
29467 int res1 = 0 ;
29468 void *argp2 = 0 ;
29469 int res2 = 0 ;
29470 PyObject * obj0 = 0 ;
29471 PyObject * obj1 = 0 ;
29472 char * kwnames[] = {
29473 (char *) "self",(char *) "other", NULL
29474 };
29475
29476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29478 if (!SWIG_IsOK(res1)) {
29479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29480 }
29481 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29482 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29483 if (!SWIG_IsOK(res2)) {
29484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29485 }
29486 if (!argp2) {
29487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29488 }
29489 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29490 {
29491 PyThreadState* __tstate = wxPyBeginAllowThreads();
29492 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29493 wxPyEndAllowThreads(__tstate);
29494 if (PyErr_Occurred()) SWIG_fail;
29495 }
29496 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29497 return resultobj;
29498 fail:
29499 return NULL;
29500 }
29501
29502
29503 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29504 PyObject *resultobj = 0;
29505 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29506 wxTimeSpan *arg2 = 0 ;
29507 wxTimeSpan result;
29508 void *argp1 = 0 ;
29509 int res1 = 0 ;
29510 void *argp2 = 0 ;
29511 int res2 = 0 ;
29512 PyObject * obj0 = 0 ;
29513 PyObject * obj1 = 0 ;
29514 char * kwnames[] = {
29515 (char *) "self",(char *) "other", NULL
29516 };
29517
29518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29520 if (!SWIG_IsOK(res1)) {
29521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29522 }
29523 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29524 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29525 if (!SWIG_IsOK(res2)) {
29526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29527 }
29528 if (!argp2) {
29529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29530 }
29531 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29532 {
29533 PyThreadState* __tstate = wxPyBeginAllowThreads();
29534 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29535 wxPyEndAllowThreads(__tstate);
29536 if (PyErr_Occurred()) SWIG_fail;
29537 }
29538 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj = 0;
29547 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29548 int arg2 ;
29549 wxTimeSpan result;
29550 void *argp1 = 0 ;
29551 int res1 = 0 ;
29552 int val2 ;
29553 int ecode2 = 0 ;
29554 PyObject * obj0 = 0 ;
29555 PyObject * obj1 = 0 ;
29556 char * kwnames[] = {
29557 (char *) "self",(char *) "n", NULL
29558 };
29559
29560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29562 if (!SWIG_IsOK(res1)) {
29563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29564 }
29565 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29566 ecode2 = SWIG_AsVal_int(obj1, &val2);
29567 if (!SWIG_IsOK(ecode2)) {
29568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29569 }
29570 arg2 = static_cast< int >(val2);
29571 {
29572 PyThreadState* __tstate = wxPyBeginAllowThreads();
29573 result = wxTimeSpan___mul__(arg1,arg2);
29574 wxPyEndAllowThreads(__tstate);
29575 if (PyErr_Occurred()) SWIG_fail;
29576 }
29577 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29578 return resultobj;
29579 fail:
29580 return NULL;
29581 }
29582
29583
29584 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29585 PyObject *resultobj = 0;
29586 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29587 int arg2 ;
29588 wxTimeSpan result;
29589 void *argp1 = 0 ;
29590 int res1 = 0 ;
29591 int val2 ;
29592 int ecode2 = 0 ;
29593 PyObject * obj0 = 0 ;
29594 PyObject * obj1 = 0 ;
29595 char * kwnames[] = {
29596 (char *) "self",(char *) "n", NULL
29597 };
29598
29599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29601 if (!SWIG_IsOK(res1)) {
29602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29603 }
29604 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29605 ecode2 = SWIG_AsVal_int(obj1, &val2);
29606 if (!SWIG_IsOK(ecode2)) {
29607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29608 }
29609 arg2 = static_cast< int >(val2);
29610 {
29611 PyThreadState* __tstate = wxPyBeginAllowThreads();
29612 result = wxTimeSpan___rmul__(arg1,arg2);
29613 wxPyEndAllowThreads(__tstate);
29614 if (PyErr_Occurred()) SWIG_fail;
29615 }
29616 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29617 return resultobj;
29618 fail:
29619 return NULL;
29620 }
29621
29622
29623 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29624 PyObject *resultobj = 0;
29625 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29626 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29627 bool result;
29628 void *argp1 = 0 ;
29629 int res1 = 0 ;
29630 void *argp2 = 0 ;
29631 int res2 = 0 ;
29632 PyObject * obj0 = 0 ;
29633 PyObject * obj1 = 0 ;
29634 char * kwnames[] = {
29635 (char *) "self",(char *) "other", NULL
29636 };
29637
29638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29640 if (!SWIG_IsOK(res1)) {
29641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29642 }
29643 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29645 if (!SWIG_IsOK(res2)) {
29646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29647 }
29648 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29652 wxPyEndAllowThreads(__tstate);
29653 if (PyErr_Occurred()) SWIG_fail;
29654 }
29655 {
29656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29657 }
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29665 PyObject *resultobj = 0;
29666 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29667 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29668 bool result;
29669 void *argp1 = 0 ;
29670 int res1 = 0 ;
29671 void *argp2 = 0 ;
29672 int res2 = 0 ;
29673 PyObject * obj0 = 0 ;
29674 PyObject * obj1 = 0 ;
29675 char * kwnames[] = {
29676 (char *) "self",(char *) "other", NULL
29677 };
29678
29679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29681 if (!SWIG_IsOK(res1)) {
29682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29683 }
29684 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29686 if (!SWIG_IsOK(res2)) {
29687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29688 }
29689 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29690 {
29691 PyThreadState* __tstate = wxPyBeginAllowThreads();
29692 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 {
29697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29698 }
29699 return resultobj;
29700 fail:
29701 return NULL;
29702 }
29703
29704
29705 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29706 PyObject *resultobj = 0;
29707 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29708 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29709 bool result;
29710 void *argp1 = 0 ;
29711 int res1 = 0 ;
29712 void *argp2 = 0 ;
29713 int res2 = 0 ;
29714 PyObject * obj0 = 0 ;
29715 PyObject * obj1 = 0 ;
29716 char * kwnames[] = {
29717 (char *) "self",(char *) "other", NULL
29718 };
29719
29720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29722 if (!SWIG_IsOK(res1)) {
29723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29724 }
29725 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29726 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29727 if (!SWIG_IsOK(res2)) {
29728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29729 }
29730 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29731 {
29732 PyThreadState* __tstate = wxPyBeginAllowThreads();
29733 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29734 wxPyEndAllowThreads(__tstate);
29735 if (PyErr_Occurred()) SWIG_fail;
29736 }
29737 {
29738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29739 }
29740 return resultobj;
29741 fail:
29742 return NULL;
29743 }
29744
29745
29746 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29747 PyObject *resultobj = 0;
29748 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29749 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29750 bool result;
29751 void *argp1 = 0 ;
29752 int res1 = 0 ;
29753 void *argp2 = 0 ;
29754 int res2 = 0 ;
29755 PyObject * obj0 = 0 ;
29756 PyObject * obj1 = 0 ;
29757 char * kwnames[] = {
29758 (char *) "self",(char *) "other", NULL
29759 };
29760
29761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29763 if (!SWIG_IsOK(res1)) {
29764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29765 }
29766 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29767 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29768 if (!SWIG_IsOK(res2)) {
29769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29770 }
29771 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29775 wxPyEndAllowThreads(__tstate);
29776 if (PyErr_Occurred()) SWIG_fail;
29777 }
29778 {
29779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29780 }
29781 return resultobj;
29782 fail:
29783 return NULL;
29784 }
29785
29786
29787 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29788 PyObject *resultobj = 0;
29789 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29790 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29791 bool result;
29792 void *argp1 = 0 ;
29793 int res1 = 0 ;
29794 void *argp2 = 0 ;
29795 int res2 = 0 ;
29796 PyObject * obj0 = 0 ;
29797 PyObject * obj1 = 0 ;
29798 char * kwnames[] = {
29799 (char *) "self",(char *) "other", NULL
29800 };
29801
29802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29804 if (!SWIG_IsOK(res1)) {
29805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29806 }
29807 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29808 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29809 if (!SWIG_IsOK(res2)) {
29810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29811 }
29812 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29813 {
29814 PyThreadState* __tstate = wxPyBeginAllowThreads();
29815 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29816 wxPyEndAllowThreads(__tstate);
29817 if (PyErr_Occurred()) SWIG_fail;
29818 }
29819 {
29820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29821 }
29822 return resultobj;
29823 fail:
29824 return NULL;
29825 }
29826
29827
29828 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29829 PyObject *resultobj = 0;
29830 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29831 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29832 bool result;
29833 void *argp1 = 0 ;
29834 int res1 = 0 ;
29835 void *argp2 = 0 ;
29836 int res2 = 0 ;
29837 PyObject * obj0 = 0 ;
29838 PyObject * obj1 = 0 ;
29839 char * kwnames[] = {
29840 (char *) "self",(char *) "other", NULL
29841 };
29842
29843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29845 if (!SWIG_IsOK(res1)) {
29846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29847 }
29848 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29849 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29850 if (!SWIG_IsOK(res2)) {
29851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29852 }
29853 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 {
29861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29862 }
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29870 PyObject *resultobj = 0;
29871 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29872 bool result;
29873 void *argp1 = 0 ;
29874 int res1 = 0 ;
29875 PyObject *swig_obj[1] ;
29876
29877 if (!args) SWIG_fail;
29878 swig_obj[0] = args;
29879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29880 if (!SWIG_IsOK(res1)) {
29881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29882 }
29883 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29884 {
29885 PyThreadState* __tstate = wxPyBeginAllowThreads();
29886 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 {
29891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29892 }
29893 return resultobj;
29894 fail:
29895 return NULL;
29896 }
29897
29898
29899 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29900 PyObject *resultobj = 0;
29901 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29902 bool result;
29903 void *argp1 = 0 ;
29904 int res1 = 0 ;
29905 PyObject *swig_obj[1] ;
29906
29907 if (!args) SWIG_fail;
29908 swig_obj[0] = args;
29909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29910 if (!SWIG_IsOK(res1)) {
29911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29912 }
29913 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 {
29921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29922 }
29923 return resultobj;
29924 fail:
29925 return NULL;
29926 }
29927
29928
29929 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29930 PyObject *resultobj = 0;
29931 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29932 bool result;
29933 void *argp1 = 0 ;
29934 int res1 = 0 ;
29935 PyObject *swig_obj[1] ;
29936
29937 if (!args) SWIG_fail;
29938 swig_obj[0] = args;
29939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29940 if (!SWIG_IsOK(res1)) {
29941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29942 }
29943 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29944 {
29945 PyThreadState* __tstate = wxPyBeginAllowThreads();
29946 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 {
29951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29952 }
29953 return resultobj;
29954 fail:
29955 return NULL;
29956 }
29957
29958
29959 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29960 PyObject *resultobj = 0;
29961 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29962 wxTimeSpan *arg2 = 0 ;
29963 bool result;
29964 void *argp1 = 0 ;
29965 int res1 = 0 ;
29966 void *argp2 = 0 ;
29967 int res2 = 0 ;
29968 PyObject * obj0 = 0 ;
29969 PyObject * obj1 = 0 ;
29970 char * kwnames[] = {
29971 (char *) "self",(char *) "ts", NULL
29972 };
29973
29974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29976 if (!SWIG_IsOK(res1)) {
29977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29978 }
29979 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29980 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29981 if (!SWIG_IsOK(res2)) {
29982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29983 }
29984 if (!argp2) {
29985 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29986 }
29987 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29988 {
29989 PyThreadState* __tstate = wxPyBeginAllowThreads();
29990 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29991 wxPyEndAllowThreads(__tstate);
29992 if (PyErr_Occurred()) SWIG_fail;
29993 }
29994 {
29995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29996 }
29997 return resultobj;
29998 fail:
29999 return NULL;
30000 }
30001
30002
30003 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30004 PyObject *resultobj = 0;
30005 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30006 wxTimeSpan *arg2 = 0 ;
30007 bool result;
30008 void *argp1 = 0 ;
30009 int res1 = 0 ;
30010 void *argp2 = 0 ;
30011 int res2 = 0 ;
30012 PyObject * obj0 = 0 ;
30013 PyObject * obj1 = 0 ;
30014 char * kwnames[] = {
30015 (char *) "self",(char *) "ts", NULL
30016 };
30017
30018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
30019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30020 if (!SWIG_IsOK(res1)) {
30021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30022 }
30023 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30024 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30025 if (!SWIG_IsOK(res2)) {
30026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30027 }
30028 if (!argp2) {
30029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30030 }
30031 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30032 {
30033 PyThreadState* __tstate = wxPyBeginAllowThreads();
30034 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
30035 wxPyEndAllowThreads(__tstate);
30036 if (PyErr_Occurred()) SWIG_fail;
30037 }
30038 {
30039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30040 }
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30048 PyObject *resultobj = 0;
30049 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30050 wxTimeSpan *arg2 = 0 ;
30051 bool result;
30052 void *argp1 = 0 ;
30053 int res1 = 0 ;
30054 void *argp2 = 0 ;
30055 int res2 = 0 ;
30056 PyObject * obj0 = 0 ;
30057 PyObject * obj1 = 0 ;
30058 char * kwnames[] = {
30059 (char *) "self",(char *) "t", NULL
30060 };
30061
30062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
30063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30064 if (!SWIG_IsOK(res1)) {
30065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30066 }
30067 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30069 if (!SWIG_IsOK(res2)) {
30070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30071 }
30072 if (!argp2) {
30073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30074 }
30075 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30076 {
30077 PyThreadState* __tstate = wxPyBeginAllowThreads();
30078 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30079 wxPyEndAllowThreads(__tstate);
30080 if (PyErr_Occurred()) SWIG_fail;
30081 }
30082 {
30083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30084 }
30085 return resultobj;
30086 fail:
30087 return NULL;
30088 }
30089
30090
30091 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30092 PyObject *resultobj = 0;
30093 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30094 int result;
30095 void *argp1 = 0 ;
30096 int res1 = 0 ;
30097 PyObject *swig_obj[1] ;
30098
30099 if (!args) SWIG_fail;
30100 swig_obj[0] = args;
30101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30102 if (!SWIG_IsOK(res1)) {
30103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30104 }
30105 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30106 {
30107 PyThreadState* __tstate = wxPyBeginAllowThreads();
30108 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 resultobj = SWIG_From_int(static_cast< int >(result));
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30120 PyObject *resultobj = 0;
30121 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30122 int result;
30123 void *argp1 = 0 ;
30124 int res1 = 0 ;
30125 PyObject *swig_obj[1] ;
30126
30127 if (!args) SWIG_fail;
30128 swig_obj[0] = args;
30129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30130 if (!SWIG_IsOK(res1)) {
30131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30132 }
30133 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30134 {
30135 PyThreadState* __tstate = wxPyBeginAllowThreads();
30136 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 resultobj = SWIG_From_int(static_cast< int >(result));
30141 return resultobj;
30142 fail:
30143 return NULL;
30144 }
30145
30146
30147 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30148 PyObject *resultobj = 0;
30149 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30150 int result;
30151 void *argp1 = 0 ;
30152 int res1 = 0 ;
30153 PyObject *swig_obj[1] ;
30154
30155 if (!args) SWIG_fail;
30156 swig_obj[0] = args;
30157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30158 if (!SWIG_IsOK(res1)) {
30159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30160 }
30161 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30162 {
30163 PyThreadState* __tstate = wxPyBeginAllowThreads();
30164 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 resultobj = SWIG_From_int(static_cast< int >(result));
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30176 PyObject *resultobj = 0;
30177 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30178 int result;
30179 void *argp1 = 0 ;
30180 int res1 = 0 ;
30181 PyObject *swig_obj[1] ;
30182
30183 if (!args) SWIG_fail;
30184 swig_obj[0] = args;
30185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30186 if (!SWIG_IsOK(res1)) {
30187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30188 }
30189 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30190 {
30191 PyThreadState* __tstate = wxPyBeginAllowThreads();
30192 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30193 wxPyEndAllowThreads(__tstate);
30194 if (PyErr_Occurred()) SWIG_fail;
30195 }
30196 resultobj = SWIG_From_int(static_cast< int >(result));
30197 return resultobj;
30198 fail:
30199 return NULL;
30200 }
30201
30202
30203 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30204 PyObject *resultobj = 0;
30205 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30206 wxLongLong result;
30207 void *argp1 = 0 ;
30208 int res1 = 0 ;
30209 PyObject *swig_obj[1] ;
30210
30211 if (!args) SWIG_fail;
30212 swig_obj[0] = args;
30213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30214 if (!SWIG_IsOK(res1)) {
30215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30216 }
30217 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30218 {
30219 PyThreadState* __tstate = wxPyBeginAllowThreads();
30220 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30221 wxPyEndAllowThreads(__tstate);
30222 if (PyErr_Occurred()) SWIG_fail;
30223 }
30224 {
30225 PyObject *hi, *lo, *shifter, *shifted;
30226 hi = PyLong_FromLong( (&result)->GetHi() );
30227 lo = PyLong_FromLong( (&result)->GetLo() );
30228 shifter = PyLong_FromLong(32);
30229 shifted = PyNumber_Lshift(hi, shifter);
30230 resultobj = PyNumber_Or(shifted, lo);
30231 Py_DECREF(hi);
30232 Py_DECREF(lo);
30233 Py_DECREF(shifter);
30234 Py_DECREF(shifted);
30235 }
30236 return resultobj;
30237 fail:
30238 return NULL;
30239 }
30240
30241
30242 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30243 PyObject *resultobj = 0;
30244 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30245 wxLongLong result;
30246 void *argp1 = 0 ;
30247 int res1 = 0 ;
30248 PyObject *swig_obj[1] ;
30249
30250 if (!args) SWIG_fail;
30251 swig_obj[0] = args;
30252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30253 if (!SWIG_IsOK(res1)) {
30254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30255 }
30256 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30257 {
30258 PyThreadState* __tstate = wxPyBeginAllowThreads();
30259 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30260 wxPyEndAllowThreads(__tstate);
30261 if (PyErr_Occurred()) SWIG_fail;
30262 }
30263 {
30264 PyObject *hi, *lo, *shifter, *shifted;
30265 hi = PyLong_FromLong( (&result)->GetHi() );
30266 lo = PyLong_FromLong( (&result)->GetLo() );
30267 shifter = PyLong_FromLong(32);
30268 shifted = PyNumber_Lshift(hi, shifter);
30269 resultobj = PyNumber_Or(shifted, lo);
30270 Py_DECREF(hi);
30271 Py_DECREF(lo);
30272 Py_DECREF(shifter);
30273 Py_DECREF(shifted);
30274 }
30275 return resultobj;
30276 fail:
30277 return NULL;
30278 }
30279
30280
30281 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30282 PyObject *resultobj = 0;
30283 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30284 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30285 wxString *arg2 = (wxString *) &arg2_defvalue ;
30286 wxString result;
30287 void *argp1 = 0 ;
30288 int res1 = 0 ;
30289 bool temp2 = false ;
30290 PyObject * obj0 = 0 ;
30291 PyObject * obj1 = 0 ;
30292 char * kwnames[] = {
30293 (char *) "self",(char *) "format", NULL
30294 };
30295
30296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30298 if (!SWIG_IsOK(res1)) {
30299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30300 }
30301 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30302 if (obj1) {
30303 {
30304 arg2 = wxString_in_helper(obj1);
30305 if (arg2 == NULL) SWIG_fail;
30306 temp2 = true;
30307 }
30308 }
30309 {
30310 PyThreadState* __tstate = wxPyBeginAllowThreads();
30311 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30312 wxPyEndAllowThreads(__tstate);
30313 if (PyErr_Occurred()) SWIG_fail;
30314 }
30315 {
30316 #if wxUSE_UNICODE
30317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30318 #else
30319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30320 #endif
30321 }
30322 {
30323 if (temp2)
30324 delete arg2;
30325 }
30326 return resultobj;
30327 fail:
30328 {
30329 if (temp2)
30330 delete arg2;
30331 }
30332 return NULL;
30333 }
30334
30335
30336 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30337 PyObject *obj;
30338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30339 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30340 return SWIG_Py_Void();
30341 }
30342
30343 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30344 return SWIG_Python_InitShadowInstance(args);
30345 }
30346
30347 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30348 PyObject *resultobj = 0;
30349 int arg1 = (int) 0 ;
30350 int arg2 = (int) 0 ;
30351 int arg3 = (int) 0 ;
30352 int arg4 = (int) 0 ;
30353 wxDateSpan *result = 0 ;
30354 int val1 ;
30355 int ecode1 = 0 ;
30356 int val2 ;
30357 int ecode2 = 0 ;
30358 int val3 ;
30359 int ecode3 = 0 ;
30360 int val4 ;
30361 int ecode4 = 0 ;
30362 PyObject * obj0 = 0 ;
30363 PyObject * obj1 = 0 ;
30364 PyObject * obj2 = 0 ;
30365 PyObject * obj3 = 0 ;
30366 char * kwnames[] = {
30367 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30368 };
30369
30370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30371 if (obj0) {
30372 ecode1 = SWIG_AsVal_int(obj0, &val1);
30373 if (!SWIG_IsOK(ecode1)) {
30374 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30375 }
30376 arg1 = static_cast< int >(val1);
30377 }
30378 if (obj1) {
30379 ecode2 = SWIG_AsVal_int(obj1, &val2);
30380 if (!SWIG_IsOK(ecode2)) {
30381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30382 }
30383 arg2 = static_cast< int >(val2);
30384 }
30385 if (obj2) {
30386 ecode3 = SWIG_AsVal_int(obj2, &val3);
30387 if (!SWIG_IsOK(ecode3)) {
30388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30389 }
30390 arg3 = static_cast< int >(val3);
30391 }
30392 if (obj3) {
30393 ecode4 = SWIG_AsVal_int(obj3, &val4);
30394 if (!SWIG_IsOK(ecode4)) {
30395 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30396 }
30397 arg4 = static_cast< int >(val4);
30398 }
30399 {
30400 PyThreadState* __tstate = wxPyBeginAllowThreads();
30401 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30413 PyObject *resultobj = 0;
30414 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 PyObject *swig_obj[1] ;
30418
30419 if (!args) SWIG_fail;
30420 swig_obj[0] = args;
30421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30422 if (!SWIG_IsOK(res1)) {
30423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30424 }
30425 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 delete arg1;
30429
30430 wxPyEndAllowThreads(__tstate);
30431 if (PyErr_Occurred()) SWIG_fail;
30432 }
30433 resultobj = SWIG_Py_Void();
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30441 PyObject *resultobj = 0;
30442 int arg1 ;
30443 wxDateSpan result;
30444 int val1 ;
30445 int ecode1 = 0 ;
30446 PyObject * obj0 = 0 ;
30447 char * kwnames[] = {
30448 (char *) "days", NULL
30449 };
30450
30451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30452 ecode1 = SWIG_AsVal_int(obj0, &val1);
30453 if (!SWIG_IsOK(ecode1)) {
30454 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30455 }
30456 arg1 = static_cast< int >(val1);
30457 {
30458 PyThreadState* __tstate = wxPyBeginAllowThreads();
30459 result = wxDateSpan::Days(arg1);
30460 wxPyEndAllowThreads(__tstate);
30461 if (PyErr_Occurred()) SWIG_fail;
30462 }
30463 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30464 return resultobj;
30465 fail:
30466 return NULL;
30467 }
30468
30469
30470 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30471 PyObject *resultobj = 0;
30472 wxDateSpan result;
30473
30474 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 result = wxDateSpan::Day();
30478 wxPyEndAllowThreads(__tstate);
30479 if (PyErr_Occurred()) SWIG_fail;
30480 }
30481 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj = 0;
30490 int arg1 ;
30491 wxDateSpan result;
30492 int val1 ;
30493 int ecode1 = 0 ;
30494 PyObject * obj0 = 0 ;
30495 char * kwnames[] = {
30496 (char *) "weeks", NULL
30497 };
30498
30499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30500 ecode1 = SWIG_AsVal_int(obj0, &val1);
30501 if (!SWIG_IsOK(ecode1)) {
30502 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30503 }
30504 arg1 = static_cast< int >(val1);
30505 {
30506 PyThreadState* __tstate = wxPyBeginAllowThreads();
30507 result = wxDateSpan::Weeks(arg1);
30508 wxPyEndAllowThreads(__tstate);
30509 if (PyErr_Occurred()) SWIG_fail;
30510 }
30511 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30512 return resultobj;
30513 fail:
30514 return NULL;
30515 }
30516
30517
30518 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30519 PyObject *resultobj = 0;
30520 wxDateSpan result;
30521
30522 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30523 {
30524 PyThreadState* __tstate = wxPyBeginAllowThreads();
30525 result = wxDateSpan::Week();
30526 wxPyEndAllowThreads(__tstate);
30527 if (PyErr_Occurred()) SWIG_fail;
30528 }
30529 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30537 PyObject *resultobj = 0;
30538 int arg1 ;
30539 wxDateSpan result;
30540 int val1 ;
30541 int ecode1 = 0 ;
30542 PyObject * obj0 = 0 ;
30543 char * kwnames[] = {
30544 (char *) "mon", NULL
30545 };
30546
30547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30548 ecode1 = SWIG_AsVal_int(obj0, &val1);
30549 if (!SWIG_IsOK(ecode1)) {
30550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30551 }
30552 arg1 = static_cast< int >(val1);
30553 {
30554 PyThreadState* __tstate = wxPyBeginAllowThreads();
30555 result = wxDateSpan::Months(arg1);
30556 wxPyEndAllowThreads(__tstate);
30557 if (PyErr_Occurred()) SWIG_fail;
30558 }
30559 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30560 return resultobj;
30561 fail:
30562 return NULL;
30563 }
30564
30565
30566 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30567 PyObject *resultobj = 0;
30568 wxDateSpan result;
30569
30570 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30571 {
30572 PyThreadState* __tstate = wxPyBeginAllowThreads();
30573 result = wxDateSpan::Month();
30574 wxPyEndAllowThreads(__tstate);
30575 if (PyErr_Occurred()) SWIG_fail;
30576 }
30577 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30578 return resultobj;
30579 fail:
30580 return NULL;
30581 }
30582
30583
30584 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30585 PyObject *resultobj = 0;
30586 int arg1 ;
30587 wxDateSpan result;
30588 int val1 ;
30589 int ecode1 = 0 ;
30590 PyObject * obj0 = 0 ;
30591 char * kwnames[] = {
30592 (char *) "years", NULL
30593 };
30594
30595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30596 ecode1 = SWIG_AsVal_int(obj0, &val1);
30597 if (!SWIG_IsOK(ecode1)) {
30598 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30599 }
30600 arg1 = static_cast< int >(val1);
30601 {
30602 PyThreadState* __tstate = wxPyBeginAllowThreads();
30603 result = wxDateSpan::Years(arg1);
30604 wxPyEndAllowThreads(__tstate);
30605 if (PyErr_Occurred()) SWIG_fail;
30606 }
30607 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30615 PyObject *resultobj = 0;
30616 wxDateSpan result;
30617
30618 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30619 {
30620 PyThreadState* __tstate = wxPyBeginAllowThreads();
30621 result = wxDateSpan::Year();
30622 wxPyEndAllowThreads(__tstate);
30623 if (PyErr_Occurred()) SWIG_fail;
30624 }
30625 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30626 return resultobj;
30627 fail:
30628 return NULL;
30629 }
30630
30631
30632 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30633 PyObject *resultobj = 0;
30634 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30635 int arg2 ;
30636 wxDateSpan *result = 0 ;
30637 void *argp1 = 0 ;
30638 int res1 = 0 ;
30639 int val2 ;
30640 int ecode2 = 0 ;
30641 PyObject * obj0 = 0 ;
30642 PyObject * obj1 = 0 ;
30643 char * kwnames[] = {
30644 (char *) "self",(char *) "n", NULL
30645 };
30646
30647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30649 if (!SWIG_IsOK(res1)) {
30650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30651 }
30652 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30653 ecode2 = SWIG_AsVal_int(obj1, &val2);
30654 if (!SWIG_IsOK(ecode2)) {
30655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30656 }
30657 arg2 = static_cast< int >(val2);
30658 {
30659 PyThreadState* __tstate = wxPyBeginAllowThreads();
30660 {
30661 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30662 result = (wxDateSpan *) &_result_ref;
30663 }
30664 wxPyEndAllowThreads(__tstate);
30665 if (PyErr_Occurred()) SWIG_fail;
30666 }
30667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30668 return resultobj;
30669 fail:
30670 return NULL;
30671 }
30672
30673
30674 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30675 PyObject *resultobj = 0;
30676 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30677 int arg2 ;
30678 wxDateSpan *result = 0 ;
30679 void *argp1 = 0 ;
30680 int res1 = 0 ;
30681 int val2 ;
30682 int ecode2 = 0 ;
30683 PyObject * obj0 = 0 ;
30684 PyObject * obj1 = 0 ;
30685 char * kwnames[] = {
30686 (char *) "self",(char *) "n", NULL
30687 };
30688
30689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30691 if (!SWIG_IsOK(res1)) {
30692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30693 }
30694 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30695 ecode2 = SWIG_AsVal_int(obj1, &val2);
30696 if (!SWIG_IsOK(ecode2)) {
30697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30698 }
30699 arg2 = static_cast< int >(val2);
30700 {
30701 PyThreadState* __tstate = wxPyBeginAllowThreads();
30702 {
30703 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30704 result = (wxDateSpan *) &_result_ref;
30705 }
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30717 PyObject *resultobj = 0;
30718 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30719 int arg2 ;
30720 wxDateSpan *result = 0 ;
30721 void *argp1 = 0 ;
30722 int res1 = 0 ;
30723 int val2 ;
30724 int ecode2 = 0 ;
30725 PyObject * obj0 = 0 ;
30726 PyObject * obj1 = 0 ;
30727 char * kwnames[] = {
30728 (char *) "self",(char *) "n", NULL
30729 };
30730
30731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30733 if (!SWIG_IsOK(res1)) {
30734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30735 }
30736 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30737 ecode2 = SWIG_AsVal_int(obj1, &val2);
30738 if (!SWIG_IsOK(ecode2)) {
30739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30740 }
30741 arg2 = static_cast< int >(val2);
30742 {
30743 PyThreadState* __tstate = wxPyBeginAllowThreads();
30744 {
30745 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30746 result = (wxDateSpan *) &_result_ref;
30747 }
30748 wxPyEndAllowThreads(__tstate);
30749 if (PyErr_Occurred()) SWIG_fail;
30750 }
30751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30752 return resultobj;
30753 fail:
30754 return NULL;
30755 }
30756
30757
30758 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30759 PyObject *resultobj = 0;
30760 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30761 int arg2 ;
30762 wxDateSpan *result = 0 ;
30763 void *argp1 = 0 ;
30764 int res1 = 0 ;
30765 int val2 ;
30766 int ecode2 = 0 ;
30767 PyObject * obj0 = 0 ;
30768 PyObject * obj1 = 0 ;
30769 char * kwnames[] = {
30770 (char *) "self",(char *) "n", NULL
30771 };
30772
30773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30775 if (!SWIG_IsOK(res1)) {
30776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30777 }
30778 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30779 ecode2 = SWIG_AsVal_int(obj1, &val2);
30780 if (!SWIG_IsOK(ecode2)) {
30781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30782 }
30783 arg2 = static_cast< int >(val2);
30784 {
30785 PyThreadState* __tstate = wxPyBeginAllowThreads();
30786 {
30787 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30788 result = (wxDateSpan *) &_result_ref;
30789 }
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30794 return resultobj;
30795 fail:
30796 return NULL;
30797 }
30798
30799
30800 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30801 PyObject *resultobj = 0;
30802 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30803 int result;
30804 void *argp1 = 0 ;
30805 int res1 = 0 ;
30806 PyObject *swig_obj[1] ;
30807
30808 if (!args) SWIG_fail;
30809 swig_obj[0] = args;
30810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30811 if (!SWIG_IsOK(res1)) {
30812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30813 }
30814 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 result = (int)((wxDateSpan const *)arg1)->GetYears();
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 resultobj = SWIG_From_int(static_cast< int >(result));
30822 return resultobj;
30823 fail:
30824 return NULL;
30825 }
30826
30827
30828 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30829 PyObject *resultobj = 0;
30830 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30831 int result;
30832 void *argp1 = 0 ;
30833 int res1 = 0 ;
30834 PyObject *swig_obj[1] ;
30835
30836 if (!args) SWIG_fail;
30837 swig_obj[0] = args;
30838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30839 if (!SWIG_IsOK(res1)) {
30840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30841 }
30842 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30843 {
30844 PyThreadState* __tstate = wxPyBeginAllowThreads();
30845 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30846 wxPyEndAllowThreads(__tstate);
30847 if (PyErr_Occurred()) SWIG_fail;
30848 }
30849 resultobj = SWIG_From_int(static_cast< int >(result));
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30857 PyObject *resultobj = 0;
30858 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30859 int result;
30860 void *argp1 = 0 ;
30861 int res1 = 0 ;
30862 PyObject *swig_obj[1] ;
30863
30864 if (!args) SWIG_fail;
30865 swig_obj[0] = args;
30866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30867 if (!SWIG_IsOK(res1)) {
30868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30869 }
30870 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30871 {
30872 PyThreadState* __tstate = wxPyBeginAllowThreads();
30873 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30874 wxPyEndAllowThreads(__tstate);
30875 if (PyErr_Occurred()) SWIG_fail;
30876 }
30877 resultobj = SWIG_From_int(static_cast< int >(result));
30878 return resultobj;
30879 fail:
30880 return NULL;
30881 }
30882
30883
30884 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30885 PyObject *resultobj = 0;
30886 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30887 int result;
30888 void *argp1 = 0 ;
30889 int res1 = 0 ;
30890 PyObject *swig_obj[1] ;
30891
30892 if (!args) SWIG_fail;
30893 swig_obj[0] = args;
30894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30895 if (!SWIG_IsOK(res1)) {
30896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30897 }
30898 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30899 {
30900 PyThreadState* __tstate = wxPyBeginAllowThreads();
30901 result = (int)((wxDateSpan const *)arg1)->GetDays();
30902 wxPyEndAllowThreads(__tstate);
30903 if (PyErr_Occurred()) SWIG_fail;
30904 }
30905 resultobj = SWIG_From_int(static_cast< int >(result));
30906 return resultobj;
30907 fail:
30908 return NULL;
30909 }
30910
30911
30912 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30913 PyObject *resultobj = 0;
30914 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30915 int result;
30916 void *argp1 = 0 ;
30917 int res1 = 0 ;
30918 PyObject *swig_obj[1] ;
30919
30920 if (!args) SWIG_fail;
30921 swig_obj[0] = args;
30922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30923 if (!SWIG_IsOK(res1)) {
30924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30925 }
30926 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30930 wxPyEndAllowThreads(__tstate);
30931 if (PyErr_Occurred()) SWIG_fail;
30932 }
30933 resultobj = SWIG_From_int(static_cast< int >(result));
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30941 PyObject *resultobj = 0;
30942 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30943 wxDateSpan *arg2 = 0 ;
30944 wxDateSpan *result = 0 ;
30945 void *argp1 = 0 ;
30946 int res1 = 0 ;
30947 void *argp2 = 0 ;
30948 int res2 = 0 ;
30949 PyObject * obj0 = 0 ;
30950 PyObject * obj1 = 0 ;
30951 char * kwnames[] = {
30952 (char *) "self",(char *) "other", NULL
30953 };
30954
30955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30957 if (!SWIG_IsOK(res1)) {
30958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30959 }
30960 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30962 if (!SWIG_IsOK(res2)) {
30963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30964 }
30965 if (!argp2) {
30966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30967 }
30968 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30969 {
30970 PyThreadState* __tstate = wxPyBeginAllowThreads();
30971 {
30972 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30973 result = (wxDateSpan *) &_result_ref;
30974 }
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30979 return resultobj;
30980 fail:
30981 return NULL;
30982 }
30983
30984
30985 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30986 PyObject *resultobj = 0;
30987 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30988 wxDateSpan *arg2 = 0 ;
30989 wxDateSpan *result = 0 ;
30990 void *argp1 = 0 ;
30991 int res1 = 0 ;
30992 void *argp2 = 0 ;
30993 int res2 = 0 ;
30994 PyObject * obj0 = 0 ;
30995 PyObject * obj1 = 0 ;
30996 char * kwnames[] = {
30997 (char *) "self",(char *) "other", NULL
30998 };
30999
31000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
31001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31002 if (!SWIG_IsOK(res1)) {
31003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31004 }
31005 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31006 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31007 if (!SWIG_IsOK(res2)) {
31008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31009 }
31010 if (!argp2) {
31011 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31012 }
31013 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31014 {
31015 PyThreadState* __tstate = wxPyBeginAllowThreads();
31016 {
31017 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
31018 result = (wxDateSpan *) &_result_ref;
31019 }
31020 wxPyEndAllowThreads(__tstate);
31021 if (PyErr_Occurred()) SWIG_fail;
31022 }
31023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31024 return resultobj;
31025 fail:
31026 return NULL;
31027 }
31028
31029
31030 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31031 PyObject *resultobj = 0;
31032 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31033 wxDateSpan *result = 0 ;
31034 void *argp1 = 0 ;
31035 int res1 = 0 ;
31036 PyObject *swig_obj[1] ;
31037
31038 if (!args) SWIG_fail;
31039 swig_obj[0] = args;
31040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31041 if (!SWIG_IsOK(res1)) {
31042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31043 }
31044 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 {
31048 wxDateSpan &_result_ref = (arg1)->Neg();
31049 result = (wxDateSpan *) &_result_ref;
31050 }
31051 wxPyEndAllowThreads(__tstate);
31052 if (PyErr_Occurred()) SWIG_fail;
31053 }
31054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31055 return resultobj;
31056 fail:
31057 return NULL;
31058 }
31059
31060
31061 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31062 PyObject *resultobj = 0;
31063 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31064 int arg2 ;
31065 wxDateSpan *result = 0 ;
31066 void *argp1 = 0 ;
31067 int res1 = 0 ;
31068 int val2 ;
31069 int ecode2 = 0 ;
31070 PyObject * obj0 = 0 ;
31071 PyObject * obj1 = 0 ;
31072 char * kwnames[] = {
31073 (char *) "self",(char *) "factor", NULL
31074 };
31075
31076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31078 if (!SWIG_IsOK(res1)) {
31079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31080 }
31081 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31082 ecode2 = SWIG_AsVal_int(obj1, &val2);
31083 if (!SWIG_IsOK(ecode2)) {
31084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31085 }
31086 arg2 = static_cast< int >(val2);
31087 {
31088 PyThreadState* __tstate = wxPyBeginAllowThreads();
31089 {
31090 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31091 result = (wxDateSpan *) &_result_ref;
31092 }
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31104 PyObject *resultobj = 0;
31105 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31106 wxDateSpan *arg2 = 0 ;
31107 wxDateSpan *result = 0 ;
31108 void *argp1 = 0 ;
31109 int res1 = 0 ;
31110 void *argp2 = 0 ;
31111 int res2 = 0 ;
31112 PyObject * obj0 = 0 ;
31113 PyObject * obj1 = 0 ;
31114 char * kwnames[] = {
31115 (char *) "self",(char *) "other", NULL
31116 };
31117
31118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31120 if (!SWIG_IsOK(res1)) {
31121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31122 }
31123 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31124 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31125 if (!SWIG_IsOK(res2)) {
31126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31127 }
31128 if (!argp2) {
31129 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31130 }
31131 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31132 {
31133 PyThreadState* __tstate = wxPyBeginAllowThreads();
31134 {
31135 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31136 result = (wxDateSpan *) &_result_ref;
31137 }
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj = 0;
31150 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31151 wxDateSpan *arg2 = 0 ;
31152 wxDateSpan *result = 0 ;
31153 void *argp1 = 0 ;
31154 int res1 = 0 ;
31155 void *argp2 = 0 ;
31156 int res2 = 0 ;
31157 PyObject * obj0 = 0 ;
31158 PyObject * obj1 = 0 ;
31159 char * kwnames[] = {
31160 (char *) "self",(char *) "other", NULL
31161 };
31162
31163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31165 if (!SWIG_IsOK(res1)) {
31166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31167 }
31168 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31170 if (!SWIG_IsOK(res2)) {
31171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31172 }
31173 if (!argp2) {
31174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31175 }
31176 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31177 {
31178 PyThreadState* __tstate = wxPyBeginAllowThreads();
31179 {
31180 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31181 result = (wxDateSpan *) &_result_ref;
31182 }
31183 wxPyEndAllowThreads(__tstate);
31184 if (PyErr_Occurred()) SWIG_fail;
31185 }
31186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31187 return resultobj;
31188 fail:
31189 return NULL;
31190 }
31191
31192
31193 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31194 PyObject *resultobj = 0;
31195 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31196 wxDateSpan *result = 0 ;
31197 void *argp1 = 0 ;
31198 int res1 = 0 ;
31199 PyObject *swig_obj[1] ;
31200
31201 if (!args) SWIG_fail;
31202 swig_obj[0] = args;
31203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31204 if (!SWIG_IsOK(res1)) {
31205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31206 }
31207 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 {
31211 wxDateSpan &_result_ref = (arg1)->operator -();
31212 result = (wxDateSpan *) &_result_ref;
31213 }
31214 wxPyEndAllowThreads(__tstate);
31215 if (PyErr_Occurred()) SWIG_fail;
31216 }
31217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31218 return resultobj;
31219 fail:
31220 return NULL;
31221 }
31222
31223
31224 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31225 PyObject *resultobj = 0;
31226 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31227 int arg2 ;
31228 wxDateSpan *result = 0 ;
31229 void *argp1 = 0 ;
31230 int res1 = 0 ;
31231 int val2 ;
31232 int ecode2 = 0 ;
31233 PyObject * obj0 = 0 ;
31234 PyObject * obj1 = 0 ;
31235 char * kwnames[] = {
31236 (char *) "self",(char *) "factor", NULL
31237 };
31238
31239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31241 if (!SWIG_IsOK(res1)) {
31242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31243 }
31244 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31245 ecode2 = SWIG_AsVal_int(obj1, &val2);
31246 if (!SWIG_IsOK(ecode2)) {
31247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31248 }
31249 arg2 = static_cast< int >(val2);
31250 {
31251 PyThreadState* __tstate = wxPyBeginAllowThreads();
31252 {
31253 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31254 result = (wxDateSpan *) &_result_ref;
31255 }
31256 wxPyEndAllowThreads(__tstate);
31257 if (PyErr_Occurred()) SWIG_fail;
31258 }
31259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31260 return resultobj;
31261 fail:
31262 return NULL;
31263 }
31264
31265
31266 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31267 PyObject *resultobj = 0;
31268 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31269 wxDateSpan *arg2 = 0 ;
31270 wxDateSpan result;
31271 void *argp1 = 0 ;
31272 int res1 = 0 ;
31273 void *argp2 = 0 ;
31274 int res2 = 0 ;
31275 PyObject * obj0 = 0 ;
31276 PyObject * obj1 = 0 ;
31277 char * kwnames[] = {
31278 (char *) "self",(char *) "other", NULL
31279 };
31280
31281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31283 if (!SWIG_IsOK(res1)) {
31284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31285 }
31286 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31287 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31288 if (!SWIG_IsOK(res2)) {
31289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31290 }
31291 if (!argp2) {
31292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31293 }
31294 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31295 {
31296 PyThreadState* __tstate = wxPyBeginAllowThreads();
31297 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31298 wxPyEndAllowThreads(__tstate);
31299 if (PyErr_Occurred()) SWIG_fail;
31300 }
31301 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31302 return resultobj;
31303 fail:
31304 return NULL;
31305 }
31306
31307
31308 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31309 PyObject *resultobj = 0;
31310 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31311 wxDateSpan *arg2 = 0 ;
31312 wxDateSpan result;
31313 void *argp1 = 0 ;
31314 int res1 = 0 ;
31315 void *argp2 = 0 ;
31316 int res2 = 0 ;
31317 PyObject * obj0 = 0 ;
31318 PyObject * obj1 = 0 ;
31319 char * kwnames[] = {
31320 (char *) "self",(char *) "other", NULL
31321 };
31322
31323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31325 if (!SWIG_IsOK(res1)) {
31326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31327 }
31328 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31329 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31330 if (!SWIG_IsOK(res2)) {
31331 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31332 }
31333 if (!argp2) {
31334 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31335 }
31336 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31337 {
31338 PyThreadState* __tstate = wxPyBeginAllowThreads();
31339 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31340 wxPyEndAllowThreads(__tstate);
31341 if (PyErr_Occurred()) SWIG_fail;
31342 }
31343 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31344 return resultobj;
31345 fail:
31346 return NULL;
31347 }
31348
31349
31350 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31351 PyObject *resultobj = 0;
31352 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31353 int arg2 ;
31354 wxDateSpan result;
31355 void *argp1 = 0 ;
31356 int res1 = 0 ;
31357 int val2 ;
31358 int ecode2 = 0 ;
31359 PyObject * obj0 = 0 ;
31360 PyObject * obj1 = 0 ;
31361 char * kwnames[] = {
31362 (char *) "self",(char *) "n", NULL
31363 };
31364
31365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31367 if (!SWIG_IsOK(res1)) {
31368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31369 }
31370 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31371 ecode2 = SWIG_AsVal_int(obj1, &val2);
31372 if (!SWIG_IsOK(ecode2)) {
31373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31374 }
31375 arg2 = static_cast< int >(val2);
31376 {
31377 PyThreadState* __tstate = wxPyBeginAllowThreads();
31378 result = wxDateSpan___mul__(arg1,arg2);
31379 wxPyEndAllowThreads(__tstate);
31380 if (PyErr_Occurred()) SWIG_fail;
31381 }
31382 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31383 return resultobj;
31384 fail:
31385 return NULL;
31386 }
31387
31388
31389 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31390 PyObject *resultobj = 0;
31391 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31392 int arg2 ;
31393 wxDateSpan result;
31394 void *argp1 = 0 ;
31395 int res1 = 0 ;
31396 int val2 ;
31397 int ecode2 = 0 ;
31398 PyObject * obj0 = 0 ;
31399 PyObject * obj1 = 0 ;
31400 char * kwnames[] = {
31401 (char *) "self",(char *) "n", NULL
31402 };
31403
31404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31406 if (!SWIG_IsOK(res1)) {
31407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31408 }
31409 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31410 ecode2 = SWIG_AsVal_int(obj1, &val2);
31411 if (!SWIG_IsOK(ecode2)) {
31412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31413 }
31414 arg2 = static_cast< int >(val2);
31415 {
31416 PyThreadState* __tstate = wxPyBeginAllowThreads();
31417 result = wxDateSpan___rmul__(arg1,arg2);
31418 wxPyEndAllowThreads(__tstate);
31419 if (PyErr_Occurred()) SWIG_fail;
31420 }
31421 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31422 return resultobj;
31423 fail:
31424 return NULL;
31425 }
31426
31427
31428 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31429 PyObject *resultobj = 0;
31430 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31431 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31432 bool result;
31433 void *argp1 = 0 ;
31434 int res1 = 0 ;
31435 void *argp2 = 0 ;
31436 int res2 = 0 ;
31437 PyObject * obj0 = 0 ;
31438 PyObject * obj1 = 0 ;
31439 char * kwnames[] = {
31440 (char *) "self",(char *) "other", NULL
31441 };
31442
31443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31445 if (!SWIG_IsOK(res1)) {
31446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31447 }
31448 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31450 if (!SWIG_IsOK(res2)) {
31451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31452 }
31453 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31454 {
31455 PyThreadState* __tstate = wxPyBeginAllowThreads();
31456 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31457 wxPyEndAllowThreads(__tstate);
31458 if (PyErr_Occurred()) SWIG_fail;
31459 }
31460 {
31461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31462 }
31463 return resultobj;
31464 fail:
31465 return NULL;
31466 }
31467
31468
31469 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31470 PyObject *resultobj = 0;
31471 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31472 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31473 bool result;
31474 void *argp1 = 0 ;
31475 int res1 = 0 ;
31476 void *argp2 = 0 ;
31477 int res2 = 0 ;
31478 PyObject * obj0 = 0 ;
31479 PyObject * obj1 = 0 ;
31480 char * kwnames[] = {
31481 (char *) "self",(char *) "other", NULL
31482 };
31483
31484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31486 if (!SWIG_IsOK(res1)) {
31487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31488 }
31489 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31490 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31491 if (!SWIG_IsOK(res2)) {
31492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31493 }
31494 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31495 {
31496 PyThreadState* __tstate = wxPyBeginAllowThreads();
31497 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 {
31502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31503 }
31504 return resultobj;
31505 fail:
31506 return NULL;
31507 }
31508
31509
31510 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31511 PyObject *obj;
31512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31513 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31514 return SWIG_Py_Void();
31515 }
31516
31517 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31518 return SWIG_Python_InitShadowInstance(args);
31519 }
31520
31521 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31522 PyObject *resultobj = 0;
31523 long result;
31524
31525 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31526 {
31527 PyThreadState* __tstate = wxPyBeginAllowThreads();
31528 result = (long)wxGetLocalTime();
31529 wxPyEndAllowThreads(__tstate);
31530 if (PyErr_Occurred()) SWIG_fail;
31531 }
31532 resultobj = SWIG_From_long(static_cast< long >(result));
31533 return resultobj;
31534 fail:
31535 return NULL;
31536 }
31537
31538
31539 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31540 PyObject *resultobj = 0;
31541 long result;
31542
31543 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31544 {
31545 PyThreadState* __tstate = wxPyBeginAllowThreads();
31546 result = (long)wxGetUTCTime();
31547 wxPyEndAllowThreads(__tstate);
31548 if (PyErr_Occurred()) SWIG_fail;
31549 }
31550 resultobj = SWIG_From_long(static_cast< long >(result));
31551 return resultobj;
31552 fail:
31553 return NULL;
31554 }
31555
31556
31557 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31558 PyObject *resultobj = 0;
31559 long result;
31560
31561 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31562 {
31563 PyThreadState* __tstate = wxPyBeginAllowThreads();
31564 result = (long)wxGetCurrentTime();
31565 wxPyEndAllowThreads(__tstate);
31566 if (PyErr_Occurred()) SWIG_fail;
31567 }
31568 resultobj = SWIG_From_long(static_cast< long >(result));
31569 return resultobj;
31570 fail:
31571 return NULL;
31572 }
31573
31574
31575 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31576 PyObject *resultobj = 0;
31577 wxLongLong result;
31578
31579 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31580 {
31581 PyThreadState* __tstate = wxPyBeginAllowThreads();
31582 result = wxGetLocalTimeMillis();
31583 wxPyEndAllowThreads(__tstate);
31584 if (PyErr_Occurred()) SWIG_fail;
31585 }
31586 {
31587 PyObject *hi, *lo, *shifter, *shifted;
31588 hi = PyLong_FromLong( (&result)->GetHi() );
31589 lo = PyLong_FromLong( (&result)->GetLo() );
31590 shifter = PyLong_FromLong(32);
31591 shifted = PyNumber_Lshift(hi, shifter);
31592 resultobj = PyNumber_Or(shifted, lo);
31593 Py_DECREF(hi);
31594 Py_DECREF(lo);
31595 Py_DECREF(shifter);
31596 Py_DECREF(shifted);
31597 }
31598 return resultobj;
31599 fail:
31600 return NULL;
31601 }
31602
31603
31604 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31605 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31606 return 1;
31607 }
31608
31609
31610 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31611 PyObject *pyobj = 0;
31612
31613 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31614 return pyobj;
31615 }
31616
31617
31618 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31619 PyObject *resultobj = 0;
31620 wxDataFormatId arg1 ;
31621 wxDataFormat *result = 0 ;
31622 int val1 ;
31623 int ecode1 = 0 ;
31624 PyObject * obj0 = 0 ;
31625 char * kwnames[] = {
31626 (char *) "type", NULL
31627 };
31628
31629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31630 ecode1 = SWIG_AsVal_int(obj0, &val1);
31631 if (!SWIG_IsOK(ecode1)) {
31632 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31633 }
31634 arg1 = static_cast< wxDataFormatId >(val1);
31635 {
31636 PyThreadState* __tstate = wxPyBeginAllowThreads();
31637 result = (wxDataFormat *)new wxDataFormat(arg1);
31638 wxPyEndAllowThreads(__tstate);
31639 if (PyErr_Occurred()) SWIG_fail;
31640 }
31641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31642 return resultobj;
31643 fail:
31644 return NULL;
31645 }
31646
31647
31648 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31649 PyObject *resultobj = 0;
31650 wxString *arg1 = 0 ;
31651 wxDataFormat *result = 0 ;
31652 bool temp1 = false ;
31653 PyObject * obj0 = 0 ;
31654 char * kwnames[] = {
31655 (char *) "format", NULL
31656 };
31657
31658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31659 {
31660 arg1 = wxString_in_helper(obj0);
31661 if (arg1 == NULL) SWIG_fail;
31662 temp1 = true;
31663 }
31664 {
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31671 {
31672 if (temp1)
31673 delete arg1;
31674 }
31675 return resultobj;
31676 fail:
31677 {
31678 if (temp1)
31679 delete arg1;
31680 }
31681 return NULL;
31682 }
31683
31684
31685 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31686 PyObject *resultobj = 0;
31687 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31688 void *argp1 = 0 ;
31689 int res1 = 0 ;
31690 PyObject *swig_obj[1] ;
31691
31692 if (!args) SWIG_fail;
31693 swig_obj[0] = args;
31694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31695 if (!SWIG_IsOK(res1)) {
31696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31697 }
31698 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31699 {
31700 PyThreadState* __tstate = wxPyBeginAllowThreads();
31701 delete arg1;
31702
31703 wxPyEndAllowThreads(__tstate);
31704 if (PyErr_Occurred()) SWIG_fail;
31705 }
31706 resultobj = SWIG_Py_Void();
31707 return resultobj;
31708 fail:
31709 return NULL;
31710 }
31711
31712
31713 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31714 PyObject *resultobj = 0;
31715 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31716 wxDataFormatId arg2 ;
31717 bool result;
31718 void *argp1 = 0 ;
31719 int res1 = 0 ;
31720 int val2 ;
31721 int ecode2 = 0 ;
31722
31723 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31725 if (!SWIG_IsOK(res1)) {
31726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31727 }
31728 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31729 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31730 if (!SWIG_IsOK(ecode2)) {
31731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31732 }
31733 arg2 = static_cast< wxDataFormatId >(val2);
31734 {
31735 PyThreadState* __tstate = wxPyBeginAllowThreads();
31736 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31737 wxPyEndAllowThreads(__tstate);
31738 if (PyErr_Occurred()) SWIG_fail;
31739 }
31740 {
31741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31742 }
31743 return resultobj;
31744 fail:
31745 return NULL;
31746 }
31747
31748
31749 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31750 PyObject *resultobj = 0;
31751 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31752 wxDataFormatId arg2 ;
31753 bool result;
31754 void *argp1 = 0 ;
31755 int res1 = 0 ;
31756 int val2 ;
31757 int ecode2 = 0 ;
31758
31759 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31761 if (!SWIG_IsOK(res1)) {
31762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31763 }
31764 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31765 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31766 if (!SWIG_IsOK(ecode2)) {
31767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31768 }
31769 arg2 = static_cast< wxDataFormatId >(val2);
31770 {
31771 PyThreadState* __tstate = wxPyBeginAllowThreads();
31772 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31773 wxPyEndAllowThreads(__tstate);
31774 if (PyErr_Occurred()) SWIG_fail;
31775 }
31776 {
31777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31778 }
31779 return resultobj;
31780 fail:
31781 return NULL;
31782 }
31783
31784
31785 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31786 PyObject *resultobj = 0;
31787 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31788 wxDataFormat *arg2 = 0 ;
31789 bool result;
31790 void *argp1 = 0 ;
31791 int res1 = 0 ;
31792 void *argp2 = 0 ;
31793 int res2 = 0 ;
31794
31795 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31797 if (!SWIG_IsOK(res1)) {
31798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31799 }
31800 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31801 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31802 if (!SWIG_IsOK(res2)) {
31803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31804 }
31805 if (!argp2) {
31806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31807 }
31808 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31809 {
31810 PyThreadState* __tstate = wxPyBeginAllowThreads();
31811 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31812 wxPyEndAllowThreads(__tstate);
31813 if (PyErr_Occurred()) SWIG_fail;
31814 }
31815 {
31816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31817 }
31818 return resultobj;
31819 fail:
31820 return NULL;
31821 }
31822
31823
31824 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31825 int argc;
31826 PyObject *argv[3];
31827
31828 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31829 --argc;
31830 if (argc == 2) {
31831 int _v = 0;
31832 {
31833 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31834 _v = SWIG_CheckState(res);
31835 }
31836 if (!_v) goto check_1;
31837 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31838 }
31839 check_1:
31840
31841 if (argc == 2) {
31842 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31843 }
31844
31845 fail:
31846 Py_INCREF(Py_NotImplemented);
31847 return Py_NotImplemented;
31848 }
31849
31850
31851 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31852 PyObject *resultobj = 0;
31853 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31854 wxDataFormat *arg2 = 0 ;
31855 bool result;
31856 void *argp1 = 0 ;
31857 int res1 = 0 ;
31858 void *argp2 = 0 ;
31859 int res2 = 0 ;
31860
31861 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31863 if (!SWIG_IsOK(res1)) {
31864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31865 }
31866 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31867 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31868 if (!SWIG_IsOK(res2)) {
31869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31870 }
31871 if (!argp2) {
31872 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31873 }
31874 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31875 {
31876 PyThreadState* __tstate = wxPyBeginAllowThreads();
31877 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 {
31882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31883 }
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31891 int argc;
31892 PyObject *argv[3];
31893
31894 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31895 --argc;
31896 if (argc == 2) {
31897 int _v = 0;
31898 {
31899 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31900 _v = SWIG_CheckState(res);
31901 }
31902 if (!_v) goto check_1;
31903 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31904 }
31905 check_1:
31906
31907 if (argc == 2) {
31908 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31909 }
31910
31911 fail:
31912 Py_INCREF(Py_NotImplemented);
31913 return Py_NotImplemented;
31914 }
31915
31916
31917 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31918 PyObject *resultobj = 0;
31919 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31920 wxDataFormatId arg2 ;
31921 void *argp1 = 0 ;
31922 int res1 = 0 ;
31923 int val2 ;
31924 int ecode2 = 0 ;
31925 PyObject * obj0 = 0 ;
31926 PyObject * obj1 = 0 ;
31927 char * kwnames[] = {
31928 (char *) "self",(char *) "format", NULL
31929 };
31930
31931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31933 if (!SWIG_IsOK(res1)) {
31934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31935 }
31936 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31937 ecode2 = SWIG_AsVal_int(obj1, &val2);
31938 if (!SWIG_IsOK(ecode2)) {
31939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31940 }
31941 arg2 = static_cast< wxDataFormatId >(val2);
31942 {
31943 PyThreadState* __tstate = wxPyBeginAllowThreads();
31944 (arg1)->SetType(arg2);
31945 wxPyEndAllowThreads(__tstate);
31946 if (PyErr_Occurred()) SWIG_fail;
31947 }
31948 resultobj = SWIG_Py_Void();
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31956 PyObject *resultobj = 0;
31957 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31958 wxDataFormatId result;
31959 void *argp1 = 0 ;
31960 int res1 = 0 ;
31961 PyObject *swig_obj[1] ;
31962
31963 if (!args) SWIG_fail;
31964 swig_obj[0] = args;
31965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31966 if (!SWIG_IsOK(res1)) {
31967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31968 }
31969 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 resultobj = SWIG_From_int(static_cast< int >(result));
31977 return resultobj;
31978 fail:
31979 return NULL;
31980 }
31981
31982
31983 SWIGINTERN PyObject *_wrap_DataFormat__GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31984 PyObject *resultobj = 0;
31985 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31986 wxString result;
31987 void *argp1 = 0 ;
31988 int res1 = 0 ;
31989 PyObject *swig_obj[1] ;
31990
31991 if (!args) SWIG_fail;
31992 swig_obj[0] = args;
31993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31994 if (!SWIG_IsOK(res1)) {
31995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat__GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31996 }
31997 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 result = ((wxDataFormat const *)arg1)->GetId();
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 {
32005 #if wxUSE_UNICODE
32006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32007 #else
32008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32009 #endif
32010 }
32011 return resultobj;
32012 fail:
32013 return NULL;
32014 }
32015
32016
32017 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32018 PyObject *resultobj = 0;
32019 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
32020 wxString *arg2 = 0 ;
32021 void *argp1 = 0 ;
32022 int res1 = 0 ;
32023 bool temp2 = false ;
32024 PyObject * obj0 = 0 ;
32025 PyObject * obj1 = 0 ;
32026 char * kwnames[] = {
32027 (char *) "self",(char *) "format", NULL
32028 };
32029
32030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
32031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
32032 if (!SWIG_IsOK(res1)) {
32033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
32034 }
32035 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32036 {
32037 arg2 = wxString_in_helper(obj1);
32038 if (arg2 == NULL) SWIG_fail;
32039 temp2 = true;
32040 }
32041 {
32042 PyThreadState* __tstate = wxPyBeginAllowThreads();
32043 (arg1)->SetId((wxString const &)*arg2);
32044 wxPyEndAllowThreads(__tstate);
32045 if (PyErr_Occurred()) SWIG_fail;
32046 }
32047 resultobj = SWIG_Py_Void();
32048 {
32049 if (temp2)
32050 delete arg2;
32051 }
32052 return resultobj;
32053 fail:
32054 {
32055 if (temp2)
32056 delete arg2;
32057 }
32058 return NULL;
32059 }
32060
32061
32062 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32063 PyObject *obj;
32064 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32065 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
32066 return SWIG_Py_Void();
32067 }
32068
32069 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32070 return SWIG_Python_InitShadowInstance(args);
32071 }
32072
32073 SWIGINTERN int FormatInvalid_set(PyObject *) {
32074 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32075 return 1;
32076 }
32077
32078
32079 SWIGINTERN PyObject *FormatInvalid_get(void) {
32080 PyObject *pyobj = 0;
32081
32082 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32083 return pyobj;
32084 }
32085
32086
32087 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32088 PyObject *resultobj = 0;
32089 wxDataObject *arg1 = (wxDataObject *) 0 ;
32090 void *argp1 = 0 ;
32091 int res1 = 0 ;
32092 PyObject *swig_obj[1] ;
32093
32094 if (!args) SWIG_fail;
32095 swig_obj[0] = args;
32096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32097 if (!SWIG_IsOK(res1)) {
32098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32099 }
32100 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32101 {
32102 PyThreadState* __tstate = wxPyBeginAllowThreads();
32103 delete arg1;
32104
32105 wxPyEndAllowThreads(__tstate);
32106 if (PyErr_Occurred()) SWIG_fail;
32107 }
32108 resultobj = SWIG_Py_Void();
32109 return resultobj;
32110 fail:
32111 return NULL;
32112 }
32113
32114
32115 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32116 PyObject *resultobj = 0;
32117 wxDataObject *arg1 = (wxDataObject *) 0 ;
32118 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32119 SwigValueWrapper<wxDataFormat > result;
32120 void *argp1 = 0 ;
32121 int res1 = 0 ;
32122 int val2 ;
32123 int ecode2 = 0 ;
32124 PyObject * obj0 = 0 ;
32125 PyObject * obj1 = 0 ;
32126 char * kwnames[] = {
32127 (char *) "self",(char *) "dir", NULL
32128 };
32129
32130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32132 if (!SWIG_IsOK(res1)) {
32133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32134 }
32135 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32136 if (obj1) {
32137 ecode2 = SWIG_AsVal_int(obj1, &val2);
32138 if (!SWIG_IsOK(ecode2)) {
32139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32140 }
32141 arg2 = static_cast< wxDataObject::Direction >(val2);
32142 }
32143 {
32144 PyThreadState* __tstate = wxPyBeginAllowThreads();
32145 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32146 wxPyEndAllowThreads(__tstate);
32147 if (PyErr_Occurred()) SWIG_fail;
32148 }
32149 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32150 return resultobj;
32151 fail:
32152 return NULL;
32153 }
32154
32155
32156 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32157 PyObject *resultobj = 0;
32158 wxDataObject *arg1 = (wxDataObject *) 0 ;
32159 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32160 size_t result;
32161 void *argp1 = 0 ;
32162 int res1 = 0 ;
32163 int val2 ;
32164 int ecode2 = 0 ;
32165 PyObject * obj0 = 0 ;
32166 PyObject * obj1 = 0 ;
32167 char * kwnames[] = {
32168 (char *) "self",(char *) "dir", NULL
32169 };
32170
32171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32173 if (!SWIG_IsOK(res1)) {
32174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32175 }
32176 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32177 if (obj1) {
32178 ecode2 = SWIG_AsVal_int(obj1, &val2);
32179 if (!SWIG_IsOK(ecode2)) {
32180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32181 }
32182 arg2 = static_cast< wxDataObject::Direction >(val2);
32183 }
32184 {
32185 PyThreadState* __tstate = wxPyBeginAllowThreads();
32186 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32187 wxPyEndAllowThreads(__tstate);
32188 if (PyErr_Occurred()) SWIG_fail;
32189 }
32190 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32191 return resultobj;
32192 fail:
32193 return NULL;
32194 }
32195
32196
32197 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32198 PyObject *resultobj = 0;
32199 wxDataObject *arg1 = (wxDataObject *) 0 ;
32200 wxDataFormat *arg2 = 0 ;
32201 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32202 bool result;
32203 void *argp1 = 0 ;
32204 int res1 = 0 ;
32205 void *argp2 = 0 ;
32206 int res2 = 0 ;
32207 int val3 ;
32208 int ecode3 = 0 ;
32209 PyObject * obj0 = 0 ;
32210 PyObject * obj1 = 0 ;
32211 PyObject * obj2 = 0 ;
32212 char * kwnames[] = {
32213 (char *) "self",(char *) "format",(char *) "dir", NULL
32214 };
32215
32216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32218 if (!SWIG_IsOK(res1)) {
32219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32220 }
32221 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32222 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32223 if (!SWIG_IsOK(res2)) {
32224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32225 }
32226 if (!argp2) {
32227 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32228 }
32229 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32230 if (obj2) {
32231 ecode3 = SWIG_AsVal_int(obj2, &val3);
32232 if (!SWIG_IsOK(ecode3)) {
32233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32234 }
32235 arg3 = static_cast< wxDataObject::Direction >(val3);
32236 }
32237 {
32238 PyThreadState* __tstate = wxPyBeginAllowThreads();
32239 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32240 wxPyEndAllowThreads(__tstate);
32241 if (PyErr_Occurred()) SWIG_fail;
32242 }
32243 {
32244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32245 }
32246 return resultobj;
32247 fail:
32248 return NULL;
32249 }
32250
32251
32252 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32253 PyObject *resultobj = 0;
32254 wxDataObject *arg1 = (wxDataObject *) 0 ;
32255 wxDataFormat *arg2 = 0 ;
32256 size_t result;
32257 void *argp1 = 0 ;
32258 int res1 = 0 ;
32259 void *argp2 = 0 ;
32260 int res2 = 0 ;
32261 PyObject * obj0 = 0 ;
32262 PyObject * obj1 = 0 ;
32263 char * kwnames[] = {
32264 (char *) "self",(char *) "format", NULL
32265 };
32266
32267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32269 if (!SWIG_IsOK(res1)) {
32270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32271 }
32272 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32273 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32274 if (!SWIG_IsOK(res2)) {
32275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32276 }
32277 if (!argp2) {
32278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32279 }
32280 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32281 {
32282 PyThreadState* __tstate = wxPyBeginAllowThreads();
32283 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32284 wxPyEndAllowThreads(__tstate);
32285 if (PyErr_Occurred()) SWIG_fail;
32286 }
32287 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32288 return resultobj;
32289 fail:
32290 return NULL;
32291 }
32292
32293
32294 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32295 PyObject *resultobj = 0;
32296 wxDataObject *arg1 = (wxDataObject *) 0 ;
32297 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32298 PyObject *result = 0 ;
32299 void *argp1 = 0 ;
32300 int res1 = 0 ;
32301 int val2 ;
32302 int ecode2 = 0 ;
32303 PyObject * obj0 = 0 ;
32304 PyObject * obj1 = 0 ;
32305 char * kwnames[] = {
32306 (char *) "self",(char *) "dir", NULL
32307 };
32308
32309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32311 if (!SWIG_IsOK(res1)) {
32312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32313 }
32314 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32315 if (obj1) {
32316 ecode2 = SWIG_AsVal_int(obj1, &val2);
32317 if (!SWIG_IsOK(ecode2)) {
32318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32319 }
32320 arg2 = static_cast< wxDataObject::Direction >(val2);
32321 }
32322 {
32323 PyThreadState* __tstate = wxPyBeginAllowThreads();
32324 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32325 wxPyEndAllowThreads(__tstate);
32326 if (PyErr_Occurred()) SWIG_fail;
32327 }
32328 resultobj = result;
32329 return resultobj;
32330 fail:
32331 return NULL;
32332 }
32333
32334
32335 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32336 PyObject *resultobj = 0;
32337 wxDataObject *arg1 = (wxDataObject *) 0 ;
32338 wxDataFormat *arg2 = 0 ;
32339 PyObject *result = 0 ;
32340 void *argp1 = 0 ;
32341 int res1 = 0 ;
32342 void *argp2 = 0 ;
32343 int res2 = 0 ;
32344 PyObject * obj0 = 0 ;
32345 PyObject * obj1 = 0 ;
32346 char * kwnames[] = {
32347 (char *) "self",(char *) "format", NULL
32348 };
32349
32350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32352 if (!SWIG_IsOK(res1)) {
32353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32354 }
32355 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32356 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32357 if (!SWIG_IsOK(res2)) {
32358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32359 }
32360 if (!argp2) {
32361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32362 }
32363 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32364 {
32365 PyThreadState* __tstate = wxPyBeginAllowThreads();
32366 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32367 wxPyEndAllowThreads(__tstate);
32368 if (PyErr_Occurred()) SWIG_fail;
32369 }
32370 resultobj = result;
32371 return resultobj;
32372 fail:
32373 return NULL;
32374 }
32375
32376
32377 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32378 PyObject *resultobj = 0;
32379 wxDataObject *arg1 = (wxDataObject *) 0 ;
32380 wxDataFormat *arg2 = 0 ;
32381 PyObject *arg3 = (PyObject *) 0 ;
32382 bool result;
32383 void *argp1 = 0 ;
32384 int res1 = 0 ;
32385 void *argp2 = 0 ;
32386 int res2 = 0 ;
32387 PyObject * obj0 = 0 ;
32388 PyObject * obj1 = 0 ;
32389 PyObject * obj2 = 0 ;
32390 char * kwnames[] = {
32391 (char *) "self",(char *) "format",(char *) "data", NULL
32392 };
32393
32394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32396 if (!SWIG_IsOK(res1)) {
32397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32398 }
32399 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32400 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32401 if (!SWIG_IsOK(res2)) {
32402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32403 }
32404 if (!argp2) {
32405 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32406 }
32407 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32408 arg3 = obj2;
32409 {
32410 PyThreadState* __tstate = wxPyBeginAllowThreads();
32411 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 {
32416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32417 }
32418 return resultobj;
32419 fail:
32420 return NULL;
32421 }
32422
32423
32424 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32425 PyObject *obj;
32426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32427 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32428 return SWIG_Py_Void();
32429 }
32430
32431 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32432 PyObject *resultobj = 0;
32433 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32434 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32435 wxDataObjectSimple *result = 0 ;
32436 void *argp1 = 0 ;
32437 int res1 = 0 ;
32438 PyObject * obj0 = 0 ;
32439 char * kwnames[] = {
32440 (char *) "format", NULL
32441 };
32442
32443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32444 if (obj0) {
32445 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32446 if (!SWIG_IsOK(res1)) {
32447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32448 }
32449 if (!argp1) {
32450 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32451 }
32452 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32453 }
32454 {
32455 PyThreadState* __tstate = wxPyBeginAllowThreads();
32456 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32457 wxPyEndAllowThreads(__tstate);
32458 if (PyErr_Occurred()) SWIG_fail;
32459 }
32460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32461 return resultobj;
32462 fail:
32463 return NULL;
32464 }
32465
32466
32467 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32468 PyObject *resultobj = 0;
32469 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32470 wxDataFormat *result = 0 ;
32471 void *argp1 = 0 ;
32472 int res1 = 0 ;
32473 PyObject *swig_obj[1] ;
32474
32475 if (!args) SWIG_fail;
32476 swig_obj[0] = args;
32477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32478 if (!SWIG_IsOK(res1)) {
32479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32480 }
32481 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32482 {
32483 PyThreadState* __tstate = wxPyBeginAllowThreads();
32484 {
32485 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32486 result = (wxDataFormat *) &_result_ref;
32487 }
32488 wxPyEndAllowThreads(__tstate);
32489 if (PyErr_Occurred()) SWIG_fail;
32490 }
32491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32492 return resultobj;
32493 fail:
32494 return NULL;
32495 }
32496
32497
32498 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32499 PyObject *resultobj = 0;
32500 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32501 wxDataFormat *arg2 = 0 ;
32502 void *argp1 = 0 ;
32503 int res1 = 0 ;
32504 void *argp2 = 0 ;
32505 int res2 = 0 ;
32506 PyObject * obj0 = 0 ;
32507 PyObject * obj1 = 0 ;
32508 char * kwnames[] = {
32509 (char *) "self",(char *) "format", NULL
32510 };
32511
32512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32514 if (!SWIG_IsOK(res1)) {
32515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32516 }
32517 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32518 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32519 if (!SWIG_IsOK(res2)) {
32520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32521 }
32522 if (!argp2) {
32523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32524 }
32525 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32526 {
32527 PyThreadState* __tstate = wxPyBeginAllowThreads();
32528 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32529 wxPyEndAllowThreads(__tstate);
32530 if (PyErr_Occurred()) SWIG_fail;
32531 }
32532 resultobj = SWIG_Py_Void();
32533 return resultobj;
32534 fail:
32535 return NULL;
32536 }
32537
32538
32539 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32540 PyObject *resultobj = 0;
32541 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32542 size_t result;
32543 void *argp1 = 0 ;
32544 int res1 = 0 ;
32545 PyObject *swig_obj[1] ;
32546
32547 if (!args) SWIG_fail;
32548 swig_obj[0] = args;
32549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32550 if (!SWIG_IsOK(res1)) {
32551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32552 }
32553 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32554 {
32555 PyThreadState* __tstate = wxPyBeginAllowThreads();
32556 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32557 wxPyEndAllowThreads(__tstate);
32558 if (PyErr_Occurred()) SWIG_fail;
32559 }
32560 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32561 return resultobj;
32562 fail:
32563 return NULL;
32564 }
32565
32566
32567 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32568 PyObject *resultobj = 0;
32569 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32570 PyObject *result = 0 ;
32571 void *argp1 = 0 ;
32572 int res1 = 0 ;
32573 PyObject *swig_obj[1] ;
32574
32575 if (!args) SWIG_fail;
32576 swig_obj[0] = args;
32577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32578 if (!SWIG_IsOK(res1)) {
32579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32580 }
32581 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32582 {
32583 PyThreadState* __tstate = wxPyBeginAllowThreads();
32584 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32585 wxPyEndAllowThreads(__tstate);
32586 if (PyErr_Occurred()) SWIG_fail;
32587 }
32588 resultobj = result;
32589 return resultobj;
32590 fail:
32591 return NULL;
32592 }
32593
32594
32595 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32596 PyObject *resultobj = 0;
32597 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32598 PyObject *arg2 = (PyObject *) 0 ;
32599 bool result;
32600 void *argp1 = 0 ;
32601 int res1 = 0 ;
32602 PyObject * obj0 = 0 ;
32603 PyObject * obj1 = 0 ;
32604 char * kwnames[] = {
32605 (char *) "self",(char *) "data", NULL
32606 };
32607
32608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32610 if (!SWIG_IsOK(res1)) {
32611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32612 }
32613 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32614 arg2 = obj1;
32615 {
32616 PyThreadState* __tstate = wxPyBeginAllowThreads();
32617 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32618 wxPyEndAllowThreads(__tstate);
32619 if (PyErr_Occurred()) SWIG_fail;
32620 }
32621 {
32622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32623 }
32624 return resultobj;
32625 fail:
32626 return NULL;
32627 }
32628
32629
32630 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32631 PyObject *obj;
32632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32633 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32634 return SWIG_Py_Void();
32635 }
32636
32637 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32638 return SWIG_Python_InitShadowInstance(args);
32639 }
32640
32641 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32642 PyObject *resultobj = 0;
32643 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32644 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32645 wxPyDataObjectSimple *result = 0 ;
32646 void *argp1 = 0 ;
32647 int res1 = 0 ;
32648 PyObject * obj0 = 0 ;
32649 char * kwnames[] = {
32650 (char *) "format", NULL
32651 };
32652
32653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32654 if (obj0) {
32655 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32656 if (!SWIG_IsOK(res1)) {
32657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32658 }
32659 if (!argp1) {
32660 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32661 }
32662 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32663 }
32664 {
32665 PyThreadState* __tstate = wxPyBeginAllowThreads();
32666 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32667 wxPyEndAllowThreads(__tstate);
32668 if (PyErr_Occurred()) SWIG_fail;
32669 }
32670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32671 return resultobj;
32672 fail:
32673 return NULL;
32674 }
32675
32676
32677 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32678 PyObject *resultobj = 0;
32679 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32680 PyObject *arg2 = (PyObject *) 0 ;
32681 PyObject *arg3 = (PyObject *) 0 ;
32682 void *argp1 = 0 ;
32683 int res1 = 0 ;
32684 PyObject * obj0 = 0 ;
32685 PyObject * obj1 = 0 ;
32686 PyObject * obj2 = 0 ;
32687 char * kwnames[] = {
32688 (char *) "self",(char *) "self",(char *) "_class", NULL
32689 };
32690
32691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32693 if (!SWIG_IsOK(res1)) {
32694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32695 }
32696 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32697 arg2 = obj1;
32698 arg3 = obj2;
32699 {
32700 PyThreadState* __tstate = wxPyBeginAllowThreads();
32701 (arg1)->_setCallbackInfo(arg2,arg3);
32702 wxPyEndAllowThreads(__tstate);
32703 if (PyErr_Occurred()) SWIG_fail;
32704 }
32705 resultobj = SWIG_Py_Void();
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32713 PyObject *obj;
32714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32715 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32716 return SWIG_Py_Void();
32717 }
32718
32719 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32720 return SWIG_Python_InitShadowInstance(args);
32721 }
32722
32723 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32724 PyObject *resultobj = 0;
32725 wxDataObjectComposite *result = 0 ;
32726
32727 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32728 {
32729 PyThreadState* __tstate = wxPyBeginAllowThreads();
32730 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32731 wxPyEndAllowThreads(__tstate);
32732 if (PyErr_Occurred()) SWIG_fail;
32733 }
32734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32735 return resultobj;
32736 fail:
32737 return NULL;
32738 }
32739
32740
32741 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32742 PyObject *resultobj = 0;
32743 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32744 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32745 bool arg3 = (bool) false ;
32746 void *argp1 = 0 ;
32747 int res1 = 0 ;
32748 int res2 = 0 ;
32749 bool val3 ;
32750 int ecode3 = 0 ;
32751 PyObject * obj0 = 0 ;
32752 PyObject * obj1 = 0 ;
32753 PyObject * obj2 = 0 ;
32754 char * kwnames[] = {
32755 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32756 };
32757
32758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32760 if (!SWIG_IsOK(res1)) {
32761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32762 }
32763 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32764 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32765 if (!SWIG_IsOK(res2)) {
32766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32767 }
32768 if (obj2) {
32769 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32770 if (!SWIG_IsOK(ecode3)) {
32771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32772 }
32773 arg3 = static_cast< bool >(val3);
32774 }
32775 {
32776 PyThreadState* __tstate = wxPyBeginAllowThreads();
32777 (arg1)->Add(arg2,arg3);
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 resultobj = SWIG_Py_Void();
32782 return resultobj;
32783 fail:
32784 return NULL;
32785 }
32786
32787
32788 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32789 PyObject *resultobj = 0;
32790 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32791 SwigValueWrapper<wxDataFormat > result;
32792 void *argp1 = 0 ;
32793 int res1 = 0 ;
32794 PyObject *swig_obj[1] ;
32795
32796 if (!args) SWIG_fail;
32797 swig_obj[0] = args;
32798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32799 if (!SWIG_IsOK(res1)) {
32800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32801 }
32802 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32803 {
32804 PyThreadState* __tstate = wxPyBeginAllowThreads();
32805 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32806 wxPyEndAllowThreads(__tstate);
32807 if (PyErr_Occurred()) SWIG_fail;
32808 }
32809 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32810 return resultobj;
32811 fail:
32812 return NULL;
32813 }
32814
32815
32816 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32817 PyObject *obj;
32818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32819 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32820 return SWIG_Py_Void();
32821 }
32822
32823 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32824 return SWIG_Python_InitShadowInstance(args);
32825 }
32826
32827 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32828 PyObject *resultobj = 0;
32829 wxString const &arg1_defvalue = wxPyEmptyString ;
32830 wxString *arg1 = (wxString *) &arg1_defvalue ;
32831 wxTextDataObject *result = 0 ;
32832 bool temp1 = false ;
32833 PyObject * obj0 = 0 ;
32834 char * kwnames[] = {
32835 (char *) "text", NULL
32836 };
32837
32838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32839 if (obj0) {
32840 {
32841 arg1 = wxString_in_helper(obj0);
32842 if (arg1 == NULL) SWIG_fail;
32843 temp1 = true;
32844 }
32845 }
32846 {
32847 PyThreadState* __tstate = wxPyBeginAllowThreads();
32848 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32849 wxPyEndAllowThreads(__tstate);
32850 if (PyErr_Occurred()) SWIG_fail;
32851 }
32852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32853 {
32854 if (temp1)
32855 delete arg1;
32856 }
32857 return resultobj;
32858 fail:
32859 {
32860 if (temp1)
32861 delete arg1;
32862 }
32863 return NULL;
32864 }
32865
32866
32867 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32868 PyObject *resultobj = 0;
32869 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32870 size_t result;
32871 void *argp1 = 0 ;
32872 int res1 = 0 ;
32873 PyObject *swig_obj[1] ;
32874
32875 if (!args) SWIG_fail;
32876 swig_obj[0] = args;
32877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32878 if (!SWIG_IsOK(res1)) {
32879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32880 }
32881 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32882 {
32883 PyThreadState* __tstate = wxPyBeginAllowThreads();
32884 result = (size_t)(arg1)->GetTextLength();
32885 wxPyEndAllowThreads(__tstate);
32886 if (PyErr_Occurred()) SWIG_fail;
32887 }
32888 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32889 return resultobj;
32890 fail:
32891 return NULL;
32892 }
32893
32894
32895 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32896 PyObject *resultobj = 0;
32897 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32898 wxString result;
32899 void *argp1 = 0 ;
32900 int res1 = 0 ;
32901 PyObject *swig_obj[1] ;
32902
32903 if (!args) SWIG_fail;
32904 swig_obj[0] = args;
32905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32906 if (!SWIG_IsOK(res1)) {
32907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32908 }
32909 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32910 {
32911 PyThreadState* __tstate = wxPyBeginAllowThreads();
32912 result = (arg1)->GetText();
32913 wxPyEndAllowThreads(__tstate);
32914 if (PyErr_Occurred()) SWIG_fail;
32915 }
32916 {
32917 #if wxUSE_UNICODE
32918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32919 #else
32920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32921 #endif
32922 }
32923 return resultobj;
32924 fail:
32925 return NULL;
32926 }
32927
32928
32929 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32930 PyObject *resultobj = 0;
32931 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32932 wxString *arg2 = 0 ;
32933 void *argp1 = 0 ;
32934 int res1 = 0 ;
32935 bool temp2 = false ;
32936 PyObject * obj0 = 0 ;
32937 PyObject * obj1 = 0 ;
32938 char * kwnames[] = {
32939 (char *) "self",(char *) "text", NULL
32940 };
32941
32942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32944 if (!SWIG_IsOK(res1)) {
32945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32946 }
32947 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32948 {
32949 arg2 = wxString_in_helper(obj1);
32950 if (arg2 == NULL) SWIG_fail;
32951 temp2 = true;
32952 }
32953 {
32954 PyThreadState* __tstate = wxPyBeginAllowThreads();
32955 (arg1)->SetText((wxString const &)*arg2);
32956 wxPyEndAllowThreads(__tstate);
32957 if (PyErr_Occurred()) SWIG_fail;
32958 }
32959 resultobj = SWIG_Py_Void();
32960 {
32961 if (temp2)
32962 delete arg2;
32963 }
32964 return resultobj;
32965 fail:
32966 {
32967 if (temp2)
32968 delete arg2;
32969 }
32970 return NULL;
32971 }
32972
32973
32974 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32975 PyObject *obj;
32976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32977 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32978 return SWIG_Py_Void();
32979 }
32980
32981 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32982 return SWIG_Python_InitShadowInstance(args);
32983 }
32984
32985 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32986 PyObject *resultobj = 0;
32987 wxString const &arg1_defvalue = wxPyEmptyString ;
32988 wxString *arg1 = (wxString *) &arg1_defvalue ;
32989 wxPyTextDataObject *result = 0 ;
32990 bool temp1 = false ;
32991 PyObject * obj0 = 0 ;
32992 char * kwnames[] = {
32993 (char *) "text", NULL
32994 };
32995
32996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32997 if (obj0) {
32998 {
32999 arg1 = wxString_in_helper(obj0);
33000 if (arg1 == NULL) SWIG_fail;
33001 temp1 = true;
33002 }
33003 }
33004 {
33005 PyThreadState* __tstate = wxPyBeginAllowThreads();
33006 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
33007 wxPyEndAllowThreads(__tstate);
33008 if (PyErr_Occurred()) SWIG_fail;
33009 }
33010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
33011 {
33012 if (temp1)
33013 delete arg1;
33014 }
33015 return resultobj;
33016 fail:
33017 {
33018 if (temp1)
33019 delete arg1;
33020 }
33021 return NULL;
33022 }
33023
33024
33025 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33026 PyObject *resultobj = 0;
33027 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
33028 PyObject *arg2 = (PyObject *) 0 ;
33029 PyObject *arg3 = (PyObject *) 0 ;
33030 void *argp1 = 0 ;
33031 int res1 = 0 ;
33032 PyObject * obj0 = 0 ;
33033 PyObject * obj1 = 0 ;
33034 PyObject * obj2 = 0 ;
33035 char * kwnames[] = {
33036 (char *) "self",(char *) "self",(char *) "_class", NULL
33037 };
33038
33039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
33041 if (!SWIG_IsOK(res1)) {
33042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
33043 }
33044 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
33045 arg2 = obj1;
33046 arg3 = obj2;
33047 {
33048 PyThreadState* __tstate = wxPyBeginAllowThreads();
33049 (arg1)->_setCallbackInfo(arg2,arg3);
33050 wxPyEndAllowThreads(__tstate);
33051 if (PyErr_Occurred()) SWIG_fail;
33052 }
33053 resultobj = SWIG_Py_Void();
33054 return resultobj;
33055 fail:
33056 return NULL;
33057 }
33058
33059
33060 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33061 PyObject *obj;
33062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33063 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
33064 return SWIG_Py_Void();
33065 }
33066
33067 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33068 return SWIG_Python_InitShadowInstance(args);
33069 }
33070
33071 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33072 PyObject *resultobj = 0;
33073 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33074 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33075 wxBitmapDataObject *result = 0 ;
33076 void *argp1 = 0 ;
33077 int res1 = 0 ;
33078 PyObject * obj0 = 0 ;
33079 char * kwnames[] = {
33080 (char *) "bitmap", NULL
33081 };
33082
33083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33084 if (obj0) {
33085 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33086 if (!SWIG_IsOK(res1)) {
33087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33088 }
33089 if (!argp1) {
33090 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33091 }
33092 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33093 }
33094 {
33095 PyThreadState* __tstate = wxPyBeginAllowThreads();
33096 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33101 return resultobj;
33102 fail:
33103 return NULL;
33104 }
33105
33106
33107 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33108 PyObject *resultobj = 0;
33109 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33110 wxBitmap result;
33111 void *argp1 = 0 ;
33112 int res1 = 0 ;
33113 PyObject *swig_obj[1] ;
33114
33115 if (!args) SWIG_fail;
33116 swig_obj[0] = args;
33117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33118 if (!SWIG_IsOK(res1)) {
33119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33120 }
33121 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33122 {
33123 PyThreadState* __tstate = wxPyBeginAllowThreads();
33124 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33125 wxPyEndAllowThreads(__tstate);
33126 if (PyErr_Occurred()) SWIG_fail;
33127 }
33128 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33129 return resultobj;
33130 fail:
33131 return NULL;
33132 }
33133
33134
33135 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33136 PyObject *resultobj = 0;
33137 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33138 wxBitmap *arg2 = 0 ;
33139 void *argp1 = 0 ;
33140 int res1 = 0 ;
33141 void *argp2 = 0 ;
33142 int res2 = 0 ;
33143 PyObject * obj0 = 0 ;
33144 PyObject * obj1 = 0 ;
33145 char * kwnames[] = {
33146 (char *) "self",(char *) "bitmap", NULL
33147 };
33148
33149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33151 if (!SWIG_IsOK(res1)) {
33152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33153 }
33154 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33155 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33156 if (!SWIG_IsOK(res2)) {
33157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33158 }
33159 if (!argp2) {
33160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33161 }
33162 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33163 {
33164 PyThreadState* __tstate = wxPyBeginAllowThreads();
33165 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33166 wxPyEndAllowThreads(__tstate);
33167 if (PyErr_Occurred()) SWIG_fail;
33168 }
33169 resultobj = SWIG_Py_Void();
33170 return resultobj;
33171 fail:
33172 return NULL;
33173 }
33174
33175
33176 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33177 PyObject *obj;
33178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33179 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33180 return SWIG_Py_Void();
33181 }
33182
33183 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33184 return SWIG_Python_InitShadowInstance(args);
33185 }
33186
33187 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33188 PyObject *resultobj = 0;
33189 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33190 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33191 wxPyBitmapDataObject *result = 0 ;
33192 void *argp1 = 0 ;
33193 int res1 = 0 ;
33194 PyObject * obj0 = 0 ;
33195 char * kwnames[] = {
33196 (char *) "bitmap", NULL
33197 };
33198
33199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33200 if (obj0) {
33201 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33202 if (!SWIG_IsOK(res1)) {
33203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33204 }
33205 if (!argp1) {
33206 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33207 }
33208 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33209 }
33210 {
33211 PyThreadState* __tstate = wxPyBeginAllowThreads();
33212 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33213 wxPyEndAllowThreads(__tstate);
33214 if (PyErr_Occurred()) SWIG_fail;
33215 }
33216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33217 return resultobj;
33218 fail:
33219 return NULL;
33220 }
33221
33222
33223 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33224 PyObject *resultobj = 0;
33225 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33226 PyObject *arg2 = (PyObject *) 0 ;
33227 PyObject *arg3 = (PyObject *) 0 ;
33228 void *argp1 = 0 ;
33229 int res1 = 0 ;
33230 PyObject * obj0 = 0 ;
33231 PyObject * obj1 = 0 ;
33232 PyObject * obj2 = 0 ;
33233 char * kwnames[] = {
33234 (char *) "self",(char *) "self",(char *) "_class", NULL
33235 };
33236
33237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33239 if (!SWIG_IsOK(res1)) {
33240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33241 }
33242 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33243 arg2 = obj1;
33244 arg3 = obj2;
33245 {
33246 PyThreadState* __tstate = wxPyBeginAllowThreads();
33247 (arg1)->_setCallbackInfo(arg2,arg3);
33248 wxPyEndAllowThreads(__tstate);
33249 if (PyErr_Occurred()) SWIG_fail;
33250 }
33251 resultobj = SWIG_Py_Void();
33252 return resultobj;
33253 fail:
33254 return NULL;
33255 }
33256
33257
33258 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33259 PyObject *obj;
33260 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33261 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33262 return SWIG_Py_Void();
33263 }
33264
33265 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33266 return SWIG_Python_InitShadowInstance(args);
33267 }
33268
33269 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33270 PyObject *resultobj = 0;
33271 wxFileDataObject *result = 0 ;
33272
33273 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33274 {
33275 PyThreadState* __tstate = wxPyBeginAllowThreads();
33276 result = (wxFileDataObject *)new wxFileDataObject();
33277 wxPyEndAllowThreads(__tstate);
33278 if (PyErr_Occurred()) SWIG_fail;
33279 }
33280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33281 return resultobj;
33282 fail:
33283 return NULL;
33284 }
33285
33286
33287 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33288 PyObject *resultobj = 0;
33289 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33290 wxArrayString *result = 0 ;
33291 void *argp1 = 0 ;
33292 int res1 = 0 ;
33293 PyObject *swig_obj[1] ;
33294
33295 if (!args) SWIG_fail;
33296 swig_obj[0] = args;
33297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33298 if (!SWIG_IsOK(res1)) {
33299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33300 }
33301 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33302 {
33303 PyThreadState* __tstate = wxPyBeginAllowThreads();
33304 {
33305 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33306 result = (wxArrayString *) &_result_ref;
33307 }
33308 wxPyEndAllowThreads(__tstate);
33309 if (PyErr_Occurred()) SWIG_fail;
33310 }
33311 {
33312 resultobj = wxArrayString2PyList_helper(*result);
33313 }
33314 return resultobj;
33315 fail:
33316 return NULL;
33317 }
33318
33319
33320 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33321 PyObject *resultobj = 0;
33322 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33323 wxString *arg2 = 0 ;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 bool temp2 = false ;
33327 PyObject * obj0 = 0 ;
33328 PyObject * obj1 = 0 ;
33329 char * kwnames[] = {
33330 (char *) "self",(char *) "filename", NULL
33331 };
33332
33333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33335 if (!SWIG_IsOK(res1)) {
33336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33337 }
33338 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33339 {
33340 arg2 = wxString_in_helper(obj1);
33341 if (arg2 == NULL) SWIG_fail;
33342 temp2 = true;
33343 }
33344 {
33345 PyThreadState* __tstate = wxPyBeginAllowThreads();
33346 (arg1)->AddFile((wxString const &)*arg2);
33347 wxPyEndAllowThreads(__tstate);
33348 if (PyErr_Occurred()) SWIG_fail;
33349 }
33350 resultobj = SWIG_Py_Void();
33351 {
33352 if (temp2)
33353 delete arg2;
33354 }
33355 return resultobj;
33356 fail:
33357 {
33358 if (temp2)
33359 delete arg2;
33360 }
33361 return NULL;
33362 }
33363
33364
33365 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33366 PyObject *obj;
33367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33368 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33369 return SWIG_Py_Void();
33370 }
33371
33372 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33373 return SWIG_Python_InitShadowInstance(args);
33374 }
33375
33376 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33377 PyObject *resultobj = 0;
33378 wxDataFormat *arg1 = 0 ;
33379 wxCustomDataObject *result = 0 ;
33380 void *argp1 = 0 ;
33381 int res1 = 0 ;
33382
33383 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33385 if (!SWIG_IsOK(res1)) {
33386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33387 }
33388 if (!argp1) {
33389 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33390 }
33391 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33392 {
33393 PyThreadState* __tstate = wxPyBeginAllowThreads();
33394 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33395 wxPyEndAllowThreads(__tstate);
33396 if (PyErr_Occurred()) SWIG_fail;
33397 }
33398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33399 return resultobj;
33400 fail:
33401 return NULL;
33402 }
33403
33404
33405 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33406 PyObject *resultobj = 0;
33407 wxString *arg1 = 0 ;
33408 wxCustomDataObject *result = 0 ;
33409 bool temp1 = false ;
33410
33411 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33412 {
33413 arg1 = wxString_in_helper(swig_obj[0]);
33414 if (arg1 == NULL) SWIG_fail;
33415 temp1 = true;
33416 }
33417 {
33418 PyThreadState* __tstate = wxPyBeginAllowThreads();
33419 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33420 wxPyEndAllowThreads(__tstate);
33421 if (PyErr_Occurred()) SWIG_fail;
33422 }
33423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33424 {
33425 if (temp1)
33426 delete arg1;
33427 }
33428 return resultobj;
33429 fail:
33430 {
33431 if (temp1)
33432 delete arg1;
33433 }
33434 return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33439 PyObject *resultobj = 0;
33440 wxCustomDataObject *result = 0 ;
33441
33442 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33443 {
33444 PyThreadState* __tstate = wxPyBeginAllowThreads();
33445 result = (wxCustomDataObject *)new wxCustomDataObject();
33446 wxPyEndAllowThreads(__tstate);
33447 if (PyErr_Occurred()) SWIG_fail;
33448 }
33449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33450 return resultobj;
33451 fail:
33452 return NULL;
33453 }
33454
33455
33456 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33457 int argc;
33458 PyObject *argv[2];
33459
33460 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33461 --argc;
33462 if (argc == 0) {
33463 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33464 }
33465 if (argc == 1) {
33466 int _v = 0;
33467 {
33468 {
33469 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33470 }
33471 }
33472 if (!_v) goto check_2;
33473 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33474 }
33475 check_2:
33476
33477 if (argc == 1) {
33478 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33479 }
33480
33481 fail:
33482 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33483 return NULL;
33484 }
33485
33486
33487 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33488 PyObject *resultobj = 0;
33489 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33490 PyObject *arg2 = (PyObject *) 0 ;
33491 bool result;
33492 void *argp1 = 0 ;
33493 int res1 = 0 ;
33494 PyObject * obj0 = 0 ;
33495 PyObject * obj1 = 0 ;
33496 char * kwnames[] = {
33497 (char *) "self",(char *) "data", NULL
33498 };
33499
33500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33502 if (!SWIG_IsOK(res1)) {
33503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33504 }
33505 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33506 arg2 = obj1;
33507 {
33508 PyThreadState* __tstate = wxPyBeginAllowThreads();
33509 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33510 wxPyEndAllowThreads(__tstate);
33511 if (PyErr_Occurred()) SWIG_fail;
33512 }
33513 {
33514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33515 }
33516 return resultobj;
33517 fail:
33518 return NULL;
33519 }
33520
33521
33522 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33523 PyObject *resultobj = 0;
33524 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33525 size_t result;
33526 void *argp1 = 0 ;
33527 int res1 = 0 ;
33528 PyObject *swig_obj[1] ;
33529
33530 if (!args) SWIG_fail;
33531 swig_obj[0] = args;
33532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33533 if (!SWIG_IsOK(res1)) {
33534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33535 }
33536 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33537 {
33538 PyThreadState* __tstate = wxPyBeginAllowThreads();
33539 result = (size_t)(arg1)->GetSize();
33540 wxPyEndAllowThreads(__tstate);
33541 if (PyErr_Occurred()) SWIG_fail;
33542 }
33543 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33544 return resultobj;
33545 fail:
33546 return NULL;
33547 }
33548
33549
33550 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33551 PyObject *resultobj = 0;
33552 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33553 PyObject *result = 0 ;
33554 void *argp1 = 0 ;
33555 int res1 = 0 ;
33556 PyObject *swig_obj[1] ;
33557
33558 if (!args) SWIG_fail;
33559 swig_obj[0] = args;
33560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33561 if (!SWIG_IsOK(res1)) {
33562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33563 }
33564 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33565 {
33566 PyThreadState* __tstate = wxPyBeginAllowThreads();
33567 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33568 wxPyEndAllowThreads(__tstate);
33569 if (PyErr_Occurred()) SWIG_fail;
33570 }
33571 resultobj = result;
33572 return resultobj;
33573 fail:
33574 return NULL;
33575 }
33576
33577
33578 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33579 PyObject *obj;
33580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33581 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33582 return SWIG_Py_Void();
33583 }
33584
33585 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33586 return SWIG_Python_InitShadowInstance(args);
33587 }
33588
33589 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33590 PyObject *resultobj = 0;
33591 wxString const &arg1_defvalue = wxPyEmptyString ;
33592 wxString *arg1 = (wxString *) &arg1_defvalue ;
33593 wxURLDataObject *result = 0 ;
33594 bool temp1 = false ;
33595 PyObject * obj0 = 0 ;
33596 char * kwnames[] = {
33597 (char *) "url", NULL
33598 };
33599
33600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33601 if (obj0) {
33602 {
33603 arg1 = wxString_in_helper(obj0);
33604 if (arg1 == NULL) SWIG_fail;
33605 temp1 = true;
33606 }
33607 }
33608 {
33609 PyThreadState* __tstate = wxPyBeginAllowThreads();
33610 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33611 wxPyEndAllowThreads(__tstate);
33612 if (PyErr_Occurred()) SWIG_fail;
33613 }
33614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33615 {
33616 if (temp1)
33617 delete arg1;
33618 }
33619 return resultobj;
33620 fail:
33621 {
33622 if (temp1)
33623 delete arg1;
33624 }
33625 return NULL;
33626 }
33627
33628
33629 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33630 PyObject *resultobj = 0;
33631 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33632 wxString result;
33633 void *argp1 = 0 ;
33634 int res1 = 0 ;
33635 PyObject *swig_obj[1] ;
33636
33637 if (!args) SWIG_fail;
33638 swig_obj[0] = args;
33639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33640 if (!SWIG_IsOK(res1)) {
33641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33642 }
33643 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33644 {
33645 PyThreadState* __tstate = wxPyBeginAllowThreads();
33646 result = (arg1)->GetURL();
33647 wxPyEndAllowThreads(__tstate);
33648 if (PyErr_Occurred()) SWIG_fail;
33649 }
33650 {
33651 #if wxUSE_UNICODE
33652 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33653 #else
33654 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33655 #endif
33656 }
33657 return resultobj;
33658 fail:
33659 return NULL;
33660 }
33661
33662
33663 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33664 PyObject *resultobj = 0;
33665 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33666 wxString *arg2 = 0 ;
33667 void *argp1 = 0 ;
33668 int res1 = 0 ;
33669 bool temp2 = false ;
33670 PyObject * obj0 = 0 ;
33671 PyObject * obj1 = 0 ;
33672 char * kwnames[] = {
33673 (char *) "self",(char *) "url", NULL
33674 };
33675
33676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33678 if (!SWIG_IsOK(res1)) {
33679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33680 }
33681 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33682 {
33683 arg2 = wxString_in_helper(obj1);
33684 if (arg2 == NULL) SWIG_fail;
33685 temp2 = true;
33686 }
33687 {
33688 PyThreadState* __tstate = wxPyBeginAllowThreads();
33689 (arg1)->SetURL((wxString const &)*arg2);
33690 wxPyEndAllowThreads(__tstate);
33691 if (PyErr_Occurred()) SWIG_fail;
33692 }
33693 resultobj = SWIG_Py_Void();
33694 {
33695 if (temp2)
33696 delete arg2;
33697 }
33698 return resultobj;
33699 fail:
33700 {
33701 if (temp2)
33702 delete arg2;
33703 }
33704 return NULL;
33705 }
33706
33707
33708 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33709 PyObject *obj;
33710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33711 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33712 return SWIG_Py_Void();
33713 }
33714
33715 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33716 return SWIG_Python_InitShadowInstance(args);
33717 }
33718
33719 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33720 PyObject *resultobj = 0;
33721 wxMetafileDataObject *result = 0 ;
33722
33723 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33724 {
33725 PyThreadState* __tstate = wxPyBeginAllowThreads();
33726 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33727 wxPyEndAllowThreads(__tstate);
33728 if (PyErr_Occurred()) SWIG_fail;
33729 }
33730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33731 return resultobj;
33732 fail:
33733 return NULL;
33734 }
33735
33736
33737 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33738 PyObject *obj;
33739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33740 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33741 return SWIG_Py_Void();
33742 }
33743
33744 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33745 return SWIG_Python_InitShadowInstance(args);
33746 }
33747
33748 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33749 PyObject *resultobj = 0;
33750 wxDragResult arg1 ;
33751 bool result;
33752 int val1 ;
33753 int ecode1 = 0 ;
33754 PyObject * obj0 = 0 ;
33755 char * kwnames[] = {
33756 (char *) "res", NULL
33757 };
33758
33759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33760 ecode1 = SWIG_AsVal_int(obj0, &val1);
33761 if (!SWIG_IsOK(ecode1)) {
33762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33763 }
33764 arg1 = static_cast< wxDragResult >(val1);
33765 {
33766 PyThreadState* __tstate = wxPyBeginAllowThreads();
33767 result = (bool)wxIsDragResultOk(arg1);
33768 wxPyEndAllowThreads(__tstate);
33769 if (PyErr_Occurred()) SWIG_fail;
33770 }
33771 {
33772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33773 }
33774 return resultobj;
33775 fail:
33776 return NULL;
33777 }
33778
33779
33780 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33781 PyObject *resultobj = 0;
33782 wxWindow *arg1 = (wxWindow *) 0 ;
33783 wxIcon const &arg2_defvalue = wxNullIcon ;
33784 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33785 wxIcon const &arg3_defvalue = wxNullIcon ;
33786 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33787 wxIcon const &arg4_defvalue = wxNullIcon ;
33788 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33789 wxPyDropSource *result = 0 ;
33790 void *argp1 = 0 ;
33791 int res1 = 0 ;
33792 void *argp2 = 0 ;
33793 int res2 = 0 ;
33794 void *argp3 = 0 ;
33795 int res3 = 0 ;
33796 void *argp4 = 0 ;
33797 int res4 = 0 ;
33798 PyObject * obj0 = 0 ;
33799 PyObject * obj1 = 0 ;
33800 PyObject * obj2 = 0 ;
33801 PyObject * obj3 = 0 ;
33802 char * kwnames[] = {
33803 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33804 };
33805
33806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33808 if (!SWIG_IsOK(res1)) {
33809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33810 }
33811 arg1 = reinterpret_cast< wxWindow * >(argp1);
33812 if (obj1) {
33813 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33814 if (!SWIG_IsOK(res2)) {
33815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33816 }
33817 if (!argp2) {
33818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33819 }
33820 arg2 = reinterpret_cast< wxIcon * >(argp2);
33821 }
33822 if (obj2) {
33823 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33824 if (!SWIG_IsOK(res3)) {
33825 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33826 }
33827 if (!argp3) {
33828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33829 }
33830 arg3 = reinterpret_cast< wxIcon * >(argp3);
33831 }
33832 if (obj3) {
33833 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33834 if (!SWIG_IsOK(res4)) {
33835 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33836 }
33837 if (!argp4) {
33838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33839 }
33840 arg4 = reinterpret_cast< wxIcon * >(argp4);
33841 }
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33845 wxPyEndAllowThreads(__tstate);
33846 if (PyErr_Occurred()) SWIG_fail;
33847 }
33848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33849 return resultobj;
33850 fail:
33851 return NULL;
33852 }
33853
33854
33855 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33856 PyObject *resultobj = 0;
33857 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33858 PyObject *arg2 = (PyObject *) 0 ;
33859 PyObject *arg3 = (PyObject *) 0 ;
33860 int arg4 = (int) 0 ;
33861 void *argp1 = 0 ;
33862 int res1 = 0 ;
33863 int val4 ;
33864 int ecode4 = 0 ;
33865 PyObject * obj0 = 0 ;
33866 PyObject * obj1 = 0 ;
33867 PyObject * obj2 = 0 ;
33868 PyObject * obj3 = 0 ;
33869 char * kwnames[] = {
33870 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33871 };
33872
33873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33875 if (!SWIG_IsOK(res1)) {
33876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33877 }
33878 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33879 arg2 = obj1;
33880 arg3 = obj2;
33881 if (obj3) {
33882 ecode4 = SWIG_AsVal_int(obj3, &val4);
33883 if (!SWIG_IsOK(ecode4)) {
33884 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33885 }
33886 arg4 = static_cast< int >(val4);
33887 }
33888 {
33889 PyThreadState* __tstate = wxPyBeginAllowThreads();
33890 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33891 wxPyEndAllowThreads(__tstate);
33892 if (PyErr_Occurred()) SWIG_fail;
33893 }
33894 resultobj = SWIG_Py_Void();
33895 return resultobj;
33896 fail:
33897 return NULL;
33898 }
33899
33900
33901 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33902 PyObject *resultobj = 0;
33903 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33904 void *argp1 = 0 ;
33905 int res1 = 0 ;
33906 PyObject *swig_obj[1] ;
33907
33908 if (!args) SWIG_fail;
33909 swig_obj[0] = args;
33910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33911 if (!SWIG_IsOK(res1)) {
33912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33913 }
33914 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33915 {
33916 PyThreadState* __tstate = wxPyBeginAllowThreads();
33917 delete arg1;
33918
33919 wxPyEndAllowThreads(__tstate);
33920 if (PyErr_Occurred()) SWIG_fail;
33921 }
33922 resultobj = SWIG_Py_Void();
33923 return resultobj;
33924 fail:
33925 return NULL;
33926 }
33927
33928
33929 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33930 PyObject *resultobj = 0;
33931 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33932 wxDataObject *arg2 = 0 ;
33933 void *argp1 = 0 ;
33934 int res1 = 0 ;
33935 void *argp2 = 0 ;
33936 int res2 = 0 ;
33937 PyObject * obj0 = 0 ;
33938 PyObject * obj1 = 0 ;
33939 char * kwnames[] = {
33940 (char *) "self",(char *) "data", NULL
33941 };
33942
33943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33945 if (!SWIG_IsOK(res1)) {
33946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33947 }
33948 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33950 if (!SWIG_IsOK(res2)) {
33951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33952 }
33953 if (!argp2) {
33954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33955 }
33956 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33957 {
33958 PyThreadState* __tstate = wxPyBeginAllowThreads();
33959 (arg1)->SetData(*arg2);
33960 wxPyEndAllowThreads(__tstate);
33961 if (PyErr_Occurred()) SWIG_fail;
33962 }
33963 resultobj = SWIG_Py_Void();
33964 return resultobj;
33965 fail:
33966 return NULL;
33967 }
33968
33969
33970 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33971 PyObject *resultobj = 0;
33972 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33973 wxDataObject *result = 0 ;
33974 void *argp1 = 0 ;
33975 int res1 = 0 ;
33976 PyObject *swig_obj[1] ;
33977
33978 if (!args) SWIG_fail;
33979 swig_obj[0] = args;
33980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33981 if (!SWIG_IsOK(res1)) {
33982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33983 }
33984 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33985 {
33986 PyThreadState* __tstate = wxPyBeginAllowThreads();
33987 result = (wxDataObject *)(arg1)->GetDataObject();
33988 wxPyEndAllowThreads(__tstate);
33989 if (PyErr_Occurred()) SWIG_fail;
33990 }
33991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33992 return resultobj;
33993 fail:
33994 return NULL;
33995 }
33996
33997
33998 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33999 PyObject *resultobj = 0;
34000 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34001 wxDragResult arg2 ;
34002 wxCursor *arg3 = 0 ;
34003 void *argp1 = 0 ;
34004 int res1 = 0 ;
34005 int val2 ;
34006 int ecode2 = 0 ;
34007 void *argp3 = 0 ;
34008 int res3 = 0 ;
34009 PyObject * obj0 = 0 ;
34010 PyObject * obj1 = 0 ;
34011 PyObject * obj2 = 0 ;
34012 char * kwnames[] = {
34013 (char *) "self",(char *) "res",(char *) "cursor", NULL
34014 };
34015
34016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34018 if (!SWIG_IsOK(res1)) {
34019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34020 }
34021 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34022 ecode2 = SWIG_AsVal_int(obj1, &val2);
34023 if (!SWIG_IsOK(ecode2)) {
34024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
34025 }
34026 arg2 = static_cast< wxDragResult >(val2);
34027 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
34028 if (!SWIG_IsOK(res3)) {
34029 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34030 }
34031 if (!argp3) {
34032 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
34033 }
34034 arg3 = reinterpret_cast< wxCursor * >(argp3);
34035 {
34036 PyThreadState* __tstate = wxPyBeginAllowThreads();
34037 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
34038 wxPyEndAllowThreads(__tstate);
34039 if (PyErr_Occurred()) SWIG_fail;
34040 }
34041 resultobj = SWIG_Py_Void();
34042 return resultobj;
34043 fail:
34044 return NULL;
34045 }
34046
34047
34048 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34049 PyObject *resultobj = 0;
34050 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34051 int arg2 = (int) wxDrag_CopyOnly ;
34052 wxDragResult result;
34053 void *argp1 = 0 ;
34054 int res1 = 0 ;
34055 int val2 ;
34056 int ecode2 = 0 ;
34057 PyObject * obj0 = 0 ;
34058 PyObject * obj1 = 0 ;
34059 char * kwnames[] = {
34060 (char *) "self",(char *) "flags", NULL
34061 };
34062
34063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34065 if (!SWIG_IsOK(res1)) {
34066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34067 }
34068 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34069 if (obj1) {
34070 ecode2 = SWIG_AsVal_int(obj1, &val2);
34071 if (!SWIG_IsOK(ecode2)) {
34072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34073 }
34074 arg2 = static_cast< int >(val2);
34075 }
34076 {
34077 PyThreadState* __tstate = wxPyBeginAllowThreads();
34078 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34079 wxPyEndAllowThreads(__tstate);
34080 if (PyErr_Occurred()) SWIG_fail;
34081 }
34082 resultobj = SWIG_From_int(static_cast< int >(result));
34083 return resultobj;
34084 fail:
34085 return NULL;
34086 }
34087
34088
34089 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34090 PyObject *resultobj = 0;
34091 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34092 wxDragResult arg2 ;
34093 bool result;
34094 void *argp1 = 0 ;
34095 int res1 = 0 ;
34096 int val2 ;
34097 int ecode2 = 0 ;
34098 PyObject * obj0 = 0 ;
34099 PyObject * obj1 = 0 ;
34100 char * kwnames[] = {
34101 (char *) "self",(char *) "effect", NULL
34102 };
34103
34104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34106 if (!SWIG_IsOK(res1)) {
34107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34108 }
34109 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34110 ecode2 = SWIG_AsVal_int(obj1, &val2);
34111 if (!SWIG_IsOK(ecode2)) {
34112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34113 }
34114 arg2 = static_cast< wxDragResult >(val2);
34115 {
34116 PyThreadState* __tstate = wxPyBeginAllowThreads();
34117 result = (bool)(arg1)->GiveFeedback(arg2);
34118 wxPyEndAllowThreads(__tstate);
34119 if (PyErr_Occurred()) SWIG_fail;
34120 }
34121 {
34122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34123 }
34124 return resultobj;
34125 fail:
34126 return NULL;
34127 }
34128
34129
34130 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34131 PyObject *obj;
34132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34133 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34134 return SWIG_Py_Void();
34135 }
34136
34137 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34138 return SWIG_Python_InitShadowInstance(args);
34139 }
34140
34141 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34142 PyObject *resultobj = 0;
34143 wxDataObject *arg1 = (wxDataObject *) NULL ;
34144 wxPyDropTarget *result = 0 ;
34145 int res1 = 0 ;
34146 PyObject * obj0 = 0 ;
34147 char * kwnames[] = {
34148 (char *) "dataObject", NULL
34149 };
34150
34151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34152 if (obj0) {
34153 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34154 if (!SWIG_IsOK(res1)) {
34155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34156 }
34157 }
34158 {
34159 PyThreadState* __tstate = wxPyBeginAllowThreads();
34160 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34161 wxPyEndAllowThreads(__tstate);
34162 if (PyErr_Occurred()) SWIG_fail;
34163 }
34164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34165 return resultobj;
34166 fail:
34167 return NULL;
34168 }
34169
34170
34171 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34172 PyObject *resultobj = 0;
34173 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34174 PyObject *arg2 = (PyObject *) 0 ;
34175 PyObject *arg3 = (PyObject *) 0 ;
34176 void *argp1 = 0 ;
34177 int res1 = 0 ;
34178 PyObject * obj0 = 0 ;
34179 PyObject * obj1 = 0 ;
34180 PyObject * obj2 = 0 ;
34181 char * kwnames[] = {
34182 (char *) "self",(char *) "self",(char *) "_class", NULL
34183 };
34184
34185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34187 if (!SWIG_IsOK(res1)) {
34188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34189 }
34190 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34191 arg2 = obj1;
34192 arg3 = obj2;
34193 {
34194 PyThreadState* __tstate = wxPyBeginAllowThreads();
34195 (arg1)->_setCallbackInfo(arg2,arg3);
34196 wxPyEndAllowThreads(__tstate);
34197 if (PyErr_Occurred()) SWIG_fail;
34198 }
34199 resultobj = SWIG_Py_Void();
34200 return resultobj;
34201 fail:
34202 return NULL;
34203 }
34204
34205
34206 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34207 PyObject *resultobj = 0;
34208 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34209 void *argp1 = 0 ;
34210 int res1 = 0 ;
34211 PyObject *swig_obj[1] ;
34212
34213 if (!args) SWIG_fail;
34214 swig_obj[0] = args;
34215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34216 if (!SWIG_IsOK(res1)) {
34217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34218 }
34219 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34220 {
34221 PyThreadState* __tstate = wxPyBeginAllowThreads();
34222 delete arg1;
34223
34224 wxPyEndAllowThreads(__tstate);
34225 if (PyErr_Occurred()) SWIG_fail;
34226 }
34227 resultobj = SWIG_Py_Void();
34228 return resultobj;
34229 fail:
34230 return NULL;
34231 }
34232
34233
34234 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34235 PyObject *resultobj = 0;
34236 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34237 wxDataObject *result = 0 ;
34238 void *argp1 = 0 ;
34239 int res1 = 0 ;
34240 PyObject *swig_obj[1] ;
34241
34242 if (!args) SWIG_fail;
34243 swig_obj[0] = args;
34244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34245 if (!SWIG_IsOK(res1)) {
34246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34247 }
34248 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34249 {
34250 PyThreadState* __tstate = wxPyBeginAllowThreads();
34251 result = (wxDataObject *)(arg1)->GetDataObject();
34252 wxPyEndAllowThreads(__tstate);
34253 if (PyErr_Occurred()) SWIG_fail;
34254 }
34255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34256 return resultobj;
34257 fail:
34258 return NULL;
34259 }
34260
34261
34262 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34263 PyObject *resultobj = 0;
34264 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34265 wxDataObject *arg2 = (wxDataObject *) 0 ;
34266 void *argp1 = 0 ;
34267 int res1 = 0 ;
34268 int res2 = 0 ;
34269 PyObject * obj0 = 0 ;
34270 PyObject * obj1 = 0 ;
34271 char * kwnames[] = {
34272 (char *) "self",(char *) "dataObject", NULL
34273 };
34274
34275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34277 if (!SWIG_IsOK(res1)) {
34278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34279 }
34280 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34281 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34282 if (!SWIG_IsOK(res2)) {
34283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34284 }
34285 {
34286 PyThreadState* __tstate = wxPyBeginAllowThreads();
34287 (arg1)->SetDataObject(arg2);
34288 wxPyEndAllowThreads(__tstate);
34289 if (PyErr_Occurred()) SWIG_fail;
34290 }
34291 resultobj = SWIG_Py_Void();
34292 return resultobj;
34293 fail:
34294 return NULL;
34295 }
34296
34297
34298 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34299 PyObject *resultobj = 0;
34300 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34301 int arg2 ;
34302 int arg3 ;
34303 wxDragResult arg4 ;
34304 wxDragResult result;
34305 void *argp1 = 0 ;
34306 int res1 = 0 ;
34307 int val2 ;
34308 int ecode2 = 0 ;
34309 int val3 ;
34310 int ecode3 = 0 ;
34311 int val4 ;
34312 int ecode4 = 0 ;
34313 PyObject * obj0 = 0 ;
34314 PyObject * obj1 = 0 ;
34315 PyObject * obj2 = 0 ;
34316 PyObject * obj3 = 0 ;
34317 char * kwnames[] = {
34318 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34319 };
34320
34321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34323 if (!SWIG_IsOK(res1)) {
34324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34325 }
34326 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34327 ecode2 = SWIG_AsVal_int(obj1, &val2);
34328 if (!SWIG_IsOK(ecode2)) {
34329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34330 }
34331 arg2 = static_cast< int >(val2);
34332 ecode3 = SWIG_AsVal_int(obj2, &val3);
34333 if (!SWIG_IsOK(ecode3)) {
34334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34335 }
34336 arg3 = static_cast< int >(val3);
34337 ecode4 = SWIG_AsVal_int(obj3, &val4);
34338 if (!SWIG_IsOK(ecode4)) {
34339 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34340 }
34341 arg4 = static_cast< wxDragResult >(val4);
34342 {
34343 PyThreadState* __tstate = wxPyBeginAllowThreads();
34344 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34345 wxPyEndAllowThreads(__tstate);
34346 if (PyErr_Occurred()) SWIG_fail;
34347 }
34348 resultobj = SWIG_From_int(static_cast< int >(result));
34349 return resultobj;
34350 fail:
34351 return NULL;
34352 }
34353
34354
34355 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34356 PyObject *resultobj = 0;
34357 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34358 int arg2 ;
34359 int arg3 ;
34360 wxDragResult arg4 ;
34361 wxDragResult result;
34362 void *argp1 = 0 ;
34363 int res1 = 0 ;
34364 int val2 ;
34365 int ecode2 = 0 ;
34366 int val3 ;
34367 int ecode3 = 0 ;
34368 int val4 ;
34369 int ecode4 = 0 ;
34370 PyObject * obj0 = 0 ;
34371 PyObject * obj1 = 0 ;
34372 PyObject * obj2 = 0 ;
34373 PyObject * obj3 = 0 ;
34374 char * kwnames[] = {
34375 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34376 };
34377
34378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34380 if (!SWIG_IsOK(res1)) {
34381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34382 }
34383 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34384 ecode2 = SWIG_AsVal_int(obj1, &val2);
34385 if (!SWIG_IsOK(ecode2)) {
34386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34387 }
34388 arg2 = static_cast< int >(val2);
34389 ecode3 = SWIG_AsVal_int(obj2, &val3);
34390 if (!SWIG_IsOK(ecode3)) {
34391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34392 }
34393 arg3 = static_cast< int >(val3);
34394 ecode4 = SWIG_AsVal_int(obj3, &val4);
34395 if (!SWIG_IsOK(ecode4)) {
34396 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34397 }
34398 arg4 = static_cast< wxDragResult >(val4);
34399 {
34400 PyThreadState* __tstate = wxPyBeginAllowThreads();
34401 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34402 wxPyEndAllowThreads(__tstate);
34403 if (PyErr_Occurred()) SWIG_fail;
34404 }
34405 resultobj = SWIG_From_int(static_cast< int >(result));
34406 return resultobj;
34407 fail:
34408 return NULL;
34409 }
34410
34411
34412 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34413 PyObject *resultobj = 0;
34414 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34415 void *argp1 = 0 ;
34416 int res1 = 0 ;
34417 PyObject *swig_obj[1] ;
34418
34419 if (!args) SWIG_fail;
34420 swig_obj[0] = args;
34421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34422 if (!SWIG_IsOK(res1)) {
34423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34424 }
34425 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34426 {
34427 PyThreadState* __tstate = wxPyBeginAllowThreads();
34428 (arg1)->OnLeave();
34429 wxPyEndAllowThreads(__tstate);
34430 if (PyErr_Occurred()) SWIG_fail;
34431 }
34432 resultobj = SWIG_Py_Void();
34433 return resultobj;
34434 fail:
34435 return NULL;
34436 }
34437
34438
34439 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34440 PyObject *resultobj = 0;
34441 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34442 int arg2 ;
34443 int arg3 ;
34444 bool result;
34445 void *argp1 = 0 ;
34446 int res1 = 0 ;
34447 int val2 ;
34448 int ecode2 = 0 ;
34449 int val3 ;
34450 int ecode3 = 0 ;
34451 PyObject * obj0 = 0 ;
34452 PyObject * obj1 = 0 ;
34453 PyObject * obj2 = 0 ;
34454 char * kwnames[] = {
34455 (char *) "self",(char *) "x",(char *) "y", NULL
34456 };
34457
34458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34460 if (!SWIG_IsOK(res1)) {
34461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34462 }
34463 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34464 ecode2 = SWIG_AsVal_int(obj1, &val2);
34465 if (!SWIG_IsOK(ecode2)) {
34466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34467 }
34468 arg2 = static_cast< int >(val2);
34469 ecode3 = SWIG_AsVal_int(obj2, &val3);
34470 if (!SWIG_IsOK(ecode3)) {
34471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34472 }
34473 arg3 = static_cast< int >(val3);
34474 {
34475 PyThreadState* __tstate = wxPyBeginAllowThreads();
34476 result = (bool)(arg1)->OnDrop(arg2,arg3);
34477 wxPyEndAllowThreads(__tstate);
34478 if (PyErr_Occurred()) SWIG_fail;
34479 }
34480 {
34481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34482 }
34483 return resultobj;
34484 fail:
34485 return NULL;
34486 }
34487
34488
34489 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34490 PyObject *resultobj = 0;
34491 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34492 bool result;
34493 void *argp1 = 0 ;
34494 int res1 = 0 ;
34495 PyObject *swig_obj[1] ;
34496
34497 if (!args) SWIG_fail;
34498 swig_obj[0] = args;
34499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34500 if (!SWIG_IsOK(res1)) {
34501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34502 }
34503 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34504 {
34505 PyThreadState* __tstate = wxPyBeginAllowThreads();
34506 result = (bool)(arg1)->GetData();
34507 wxPyEndAllowThreads(__tstate);
34508 if (PyErr_Occurred()) SWIG_fail;
34509 }
34510 {
34511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34512 }
34513 return resultobj;
34514 fail:
34515 return NULL;
34516 }
34517
34518
34519 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34520 PyObject *resultobj = 0;
34521 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34522 wxDragResult arg2 ;
34523 void *argp1 = 0 ;
34524 int res1 = 0 ;
34525 int val2 ;
34526 int ecode2 = 0 ;
34527 PyObject * obj0 = 0 ;
34528 PyObject * obj1 = 0 ;
34529 char * kwnames[] = {
34530 (char *) "self",(char *) "action", NULL
34531 };
34532
34533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34535 if (!SWIG_IsOK(res1)) {
34536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34537 }
34538 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34539 ecode2 = SWIG_AsVal_int(obj1, &val2);
34540 if (!SWIG_IsOK(ecode2)) {
34541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34542 }
34543 arg2 = static_cast< wxDragResult >(val2);
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 (arg1)->SetDefaultAction(arg2);
34547 wxPyEndAllowThreads(__tstate);
34548 if (PyErr_Occurred()) SWIG_fail;
34549 }
34550 resultobj = SWIG_Py_Void();
34551 return resultobj;
34552 fail:
34553 return NULL;
34554 }
34555
34556
34557 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34558 PyObject *resultobj = 0;
34559 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34560 wxDragResult result;
34561 void *argp1 = 0 ;
34562 int res1 = 0 ;
34563 PyObject *swig_obj[1] ;
34564
34565 if (!args) SWIG_fail;
34566 swig_obj[0] = args;
34567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34568 if (!SWIG_IsOK(res1)) {
34569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34570 }
34571 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34572 {
34573 PyThreadState* __tstate = wxPyBeginAllowThreads();
34574 result = (wxDragResult)(arg1)->GetDefaultAction();
34575 wxPyEndAllowThreads(__tstate);
34576 if (PyErr_Occurred()) SWIG_fail;
34577 }
34578 resultobj = SWIG_From_int(static_cast< int >(result));
34579 return resultobj;
34580 fail:
34581 return NULL;
34582 }
34583
34584
34585 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34586 PyObject *obj;
34587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34588 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34589 return SWIG_Py_Void();
34590 }
34591
34592 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34593 return SWIG_Python_InitShadowInstance(args);
34594 }
34595
34596 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34597 PyObject *resultobj = 0;
34598 wxPyTextDropTarget *result = 0 ;
34599
34600 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34601 {
34602 PyThreadState* __tstate = wxPyBeginAllowThreads();
34603 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34604 wxPyEndAllowThreads(__tstate);
34605 if (PyErr_Occurred()) SWIG_fail;
34606 }
34607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34608 return resultobj;
34609 fail:
34610 return NULL;
34611 }
34612
34613
34614 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34615 PyObject *resultobj = 0;
34616 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34617 PyObject *arg2 = (PyObject *) 0 ;
34618 PyObject *arg3 = (PyObject *) 0 ;
34619 void *argp1 = 0 ;
34620 int res1 = 0 ;
34621 PyObject * obj0 = 0 ;
34622 PyObject * obj1 = 0 ;
34623 PyObject * obj2 = 0 ;
34624 char * kwnames[] = {
34625 (char *) "self",(char *) "self",(char *) "_class", NULL
34626 };
34627
34628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34630 if (!SWIG_IsOK(res1)) {
34631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34632 }
34633 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34634 arg2 = obj1;
34635 arg3 = obj2;
34636 {
34637 PyThreadState* __tstate = wxPyBeginAllowThreads();
34638 (arg1)->_setCallbackInfo(arg2,arg3);
34639 wxPyEndAllowThreads(__tstate);
34640 if (PyErr_Occurred()) SWIG_fail;
34641 }
34642 resultobj = SWIG_Py_Void();
34643 return resultobj;
34644 fail:
34645 return NULL;
34646 }
34647
34648
34649 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34650 PyObject *resultobj = 0;
34651 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34652 int arg2 ;
34653 int arg3 ;
34654 wxString *arg4 = 0 ;
34655 bool result;
34656 void *argp1 = 0 ;
34657 int res1 = 0 ;
34658 int val2 ;
34659 int ecode2 = 0 ;
34660 int val3 ;
34661 int ecode3 = 0 ;
34662 bool temp4 = false ;
34663 PyObject * obj0 = 0 ;
34664 PyObject * obj1 = 0 ;
34665 PyObject * obj2 = 0 ;
34666 PyObject * obj3 = 0 ;
34667 char * kwnames[] = {
34668 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34669 };
34670
34671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34673 if (!SWIG_IsOK(res1)) {
34674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34675 }
34676 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34677 ecode2 = SWIG_AsVal_int(obj1, &val2);
34678 if (!SWIG_IsOK(ecode2)) {
34679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34680 }
34681 arg2 = static_cast< int >(val2);
34682 ecode3 = SWIG_AsVal_int(obj2, &val3);
34683 if (!SWIG_IsOK(ecode3)) {
34684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34685 }
34686 arg3 = static_cast< int >(val3);
34687 {
34688 arg4 = wxString_in_helper(obj3);
34689 if (arg4 == NULL) SWIG_fail;
34690 temp4 = true;
34691 }
34692 {
34693 PyThreadState* __tstate = wxPyBeginAllowThreads();
34694 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34695 wxPyEndAllowThreads(__tstate);
34696 if (PyErr_Occurred()) SWIG_fail;
34697 }
34698 {
34699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34700 }
34701 {
34702 if (temp4)
34703 delete arg4;
34704 }
34705 return resultobj;
34706 fail:
34707 {
34708 if (temp4)
34709 delete arg4;
34710 }
34711 return NULL;
34712 }
34713
34714
34715 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34716 PyObject *resultobj = 0;
34717 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34718 int arg2 ;
34719 int arg3 ;
34720 wxDragResult arg4 ;
34721 wxDragResult result;
34722 void *argp1 = 0 ;
34723 int res1 = 0 ;
34724 int val2 ;
34725 int ecode2 = 0 ;
34726 int val3 ;
34727 int ecode3 = 0 ;
34728 int val4 ;
34729 int ecode4 = 0 ;
34730 PyObject * obj0 = 0 ;
34731 PyObject * obj1 = 0 ;
34732 PyObject * obj2 = 0 ;
34733 PyObject * obj3 = 0 ;
34734 char * kwnames[] = {
34735 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34736 };
34737
34738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34740 if (!SWIG_IsOK(res1)) {
34741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34742 }
34743 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34744 ecode2 = SWIG_AsVal_int(obj1, &val2);
34745 if (!SWIG_IsOK(ecode2)) {
34746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34747 }
34748 arg2 = static_cast< int >(val2);
34749 ecode3 = SWIG_AsVal_int(obj2, &val3);
34750 if (!SWIG_IsOK(ecode3)) {
34751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34752 }
34753 arg3 = static_cast< int >(val3);
34754 ecode4 = SWIG_AsVal_int(obj3, &val4);
34755 if (!SWIG_IsOK(ecode4)) {
34756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34757 }
34758 arg4 = static_cast< wxDragResult >(val4);
34759 {
34760 PyThreadState* __tstate = wxPyBeginAllowThreads();
34761 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34762 wxPyEndAllowThreads(__tstate);
34763 if (PyErr_Occurred()) SWIG_fail;
34764 }
34765 resultobj = SWIG_From_int(static_cast< int >(result));
34766 return resultobj;
34767 fail:
34768 return NULL;
34769 }
34770
34771
34772 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34773 PyObject *resultobj = 0;
34774 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34775 int arg2 ;
34776 int arg3 ;
34777 wxDragResult arg4 ;
34778 wxDragResult result;
34779 void *argp1 = 0 ;
34780 int res1 = 0 ;
34781 int val2 ;
34782 int ecode2 = 0 ;
34783 int val3 ;
34784 int ecode3 = 0 ;
34785 int val4 ;
34786 int ecode4 = 0 ;
34787 PyObject * obj0 = 0 ;
34788 PyObject * obj1 = 0 ;
34789 PyObject * obj2 = 0 ;
34790 PyObject * obj3 = 0 ;
34791 char * kwnames[] = {
34792 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34793 };
34794
34795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34797 if (!SWIG_IsOK(res1)) {
34798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34799 }
34800 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34801 ecode2 = SWIG_AsVal_int(obj1, &val2);
34802 if (!SWIG_IsOK(ecode2)) {
34803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34804 }
34805 arg2 = static_cast< int >(val2);
34806 ecode3 = SWIG_AsVal_int(obj2, &val3);
34807 if (!SWIG_IsOK(ecode3)) {
34808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34809 }
34810 arg3 = static_cast< int >(val3);
34811 ecode4 = SWIG_AsVal_int(obj3, &val4);
34812 if (!SWIG_IsOK(ecode4)) {
34813 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34814 }
34815 arg4 = static_cast< wxDragResult >(val4);
34816 {
34817 PyThreadState* __tstate = wxPyBeginAllowThreads();
34818 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34819 wxPyEndAllowThreads(__tstate);
34820 if (PyErr_Occurred()) SWIG_fail;
34821 }
34822 resultobj = SWIG_From_int(static_cast< int >(result));
34823 return resultobj;
34824 fail:
34825 return NULL;
34826 }
34827
34828
34829 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34830 PyObject *resultobj = 0;
34831 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34832 void *argp1 = 0 ;
34833 int res1 = 0 ;
34834 PyObject *swig_obj[1] ;
34835
34836 if (!args) SWIG_fail;
34837 swig_obj[0] = args;
34838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34839 if (!SWIG_IsOK(res1)) {
34840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34841 }
34842 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34843 {
34844 PyThreadState* __tstate = wxPyBeginAllowThreads();
34845 (arg1)->OnLeave();
34846 wxPyEndAllowThreads(__tstate);
34847 if (PyErr_Occurred()) SWIG_fail;
34848 }
34849 resultobj = SWIG_Py_Void();
34850 return resultobj;
34851 fail:
34852 return NULL;
34853 }
34854
34855
34856 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34857 PyObject *resultobj = 0;
34858 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34859 int arg2 ;
34860 int arg3 ;
34861 bool result;
34862 void *argp1 = 0 ;
34863 int res1 = 0 ;
34864 int val2 ;
34865 int ecode2 = 0 ;
34866 int val3 ;
34867 int ecode3 = 0 ;
34868 PyObject * obj0 = 0 ;
34869 PyObject * obj1 = 0 ;
34870 PyObject * obj2 = 0 ;
34871 char * kwnames[] = {
34872 (char *) "self",(char *) "x",(char *) "y", NULL
34873 };
34874
34875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34877 if (!SWIG_IsOK(res1)) {
34878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34879 }
34880 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34881 ecode2 = SWIG_AsVal_int(obj1, &val2);
34882 if (!SWIG_IsOK(ecode2)) {
34883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34884 }
34885 arg2 = static_cast< int >(val2);
34886 ecode3 = SWIG_AsVal_int(obj2, &val3);
34887 if (!SWIG_IsOK(ecode3)) {
34888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34889 }
34890 arg3 = static_cast< int >(val3);
34891 {
34892 PyThreadState* __tstate = wxPyBeginAllowThreads();
34893 result = (bool)(arg1)->OnDrop(arg2,arg3);
34894 wxPyEndAllowThreads(__tstate);
34895 if (PyErr_Occurred()) SWIG_fail;
34896 }
34897 {
34898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34899 }
34900 return resultobj;
34901 fail:
34902 return NULL;
34903 }
34904
34905
34906 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34907 PyObject *resultobj = 0;
34908 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34909 int arg2 ;
34910 int arg3 ;
34911 wxDragResult arg4 ;
34912 wxDragResult result;
34913 void *argp1 = 0 ;
34914 int res1 = 0 ;
34915 int val2 ;
34916 int ecode2 = 0 ;
34917 int val3 ;
34918 int ecode3 = 0 ;
34919 int val4 ;
34920 int ecode4 = 0 ;
34921 PyObject * obj0 = 0 ;
34922 PyObject * obj1 = 0 ;
34923 PyObject * obj2 = 0 ;
34924 PyObject * obj3 = 0 ;
34925 char * kwnames[] = {
34926 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34927 };
34928
34929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34931 if (!SWIG_IsOK(res1)) {
34932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34933 }
34934 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34935 ecode2 = SWIG_AsVal_int(obj1, &val2);
34936 if (!SWIG_IsOK(ecode2)) {
34937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34938 }
34939 arg2 = static_cast< int >(val2);
34940 ecode3 = SWIG_AsVal_int(obj2, &val3);
34941 if (!SWIG_IsOK(ecode3)) {
34942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34943 }
34944 arg3 = static_cast< int >(val3);
34945 ecode4 = SWIG_AsVal_int(obj3, &val4);
34946 if (!SWIG_IsOK(ecode4)) {
34947 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34948 }
34949 arg4 = static_cast< wxDragResult >(val4);
34950 {
34951 PyThreadState* __tstate = wxPyBeginAllowThreads();
34952 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34953 wxPyEndAllowThreads(__tstate);
34954 if (PyErr_Occurred()) SWIG_fail;
34955 }
34956 resultobj = SWIG_From_int(static_cast< int >(result));
34957 return resultobj;
34958 fail:
34959 return NULL;
34960 }
34961
34962
34963 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34964 PyObject *obj;
34965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34966 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34967 return SWIG_Py_Void();
34968 }
34969
34970 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34971 return SWIG_Python_InitShadowInstance(args);
34972 }
34973
34974 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34975 PyObject *resultobj = 0;
34976 wxPyFileDropTarget *result = 0 ;
34977
34978 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34979 {
34980 PyThreadState* __tstate = wxPyBeginAllowThreads();
34981 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34982 wxPyEndAllowThreads(__tstate);
34983 if (PyErr_Occurred()) SWIG_fail;
34984 }
34985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34986 return resultobj;
34987 fail:
34988 return NULL;
34989 }
34990
34991
34992 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34993 PyObject *resultobj = 0;
34994 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34995 PyObject *arg2 = (PyObject *) 0 ;
34996 PyObject *arg3 = (PyObject *) 0 ;
34997 void *argp1 = 0 ;
34998 int res1 = 0 ;
34999 PyObject * obj0 = 0 ;
35000 PyObject * obj1 = 0 ;
35001 PyObject * obj2 = 0 ;
35002 char * kwnames[] = {
35003 (char *) "self",(char *) "self",(char *) "_class", NULL
35004 };
35005
35006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35008 if (!SWIG_IsOK(res1)) {
35009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35010 }
35011 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35012 arg2 = obj1;
35013 arg3 = obj2;
35014 {
35015 PyThreadState* __tstate = wxPyBeginAllowThreads();
35016 (arg1)->_setCallbackInfo(arg2,arg3);
35017 wxPyEndAllowThreads(__tstate);
35018 if (PyErr_Occurred()) SWIG_fail;
35019 }
35020 resultobj = SWIG_Py_Void();
35021 return resultobj;
35022 fail:
35023 return NULL;
35024 }
35025
35026
35027 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35028 PyObject *resultobj = 0;
35029 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35030 int arg2 ;
35031 int arg3 ;
35032 wxArrayString *arg4 = 0 ;
35033 bool result;
35034 void *argp1 = 0 ;
35035 int res1 = 0 ;
35036 int val2 ;
35037 int ecode2 = 0 ;
35038 int val3 ;
35039 int ecode3 = 0 ;
35040 bool temp4 = false ;
35041 PyObject * obj0 = 0 ;
35042 PyObject * obj1 = 0 ;
35043 PyObject * obj2 = 0 ;
35044 PyObject * obj3 = 0 ;
35045 char * kwnames[] = {
35046 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
35047 };
35048
35049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35051 if (!SWIG_IsOK(res1)) {
35052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35053 }
35054 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35055 ecode2 = SWIG_AsVal_int(obj1, &val2);
35056 if (!SWIG_IsOK(ecode2)) {
35057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35058 }
35059 arg2 = static_cast< int >(val2);
35060 ecode3 = SWIG_AsVal_int(obj2, &val3);
35061 if (!SWIG_IsOK(ecode3)) {
35062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35063 }
35064 arg3 = static_cast< int >(val3);
35065 {
35066 if (! PySequence_Check(obj3)) {
35067 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35068 SWIG_fail;
35069 }
35070 arg4 = new wxArrayString;
35071 temp4 = true;
35072 int i, len=PySequence_Length(obj3);
35073 for (i=0; i<len; i++) {
35074 PyObject* item = PySequence_GetItem(obj3, i);
35075 wxString* s = wxString_in_helper(item);
35076 if (PyErr_Occurred()) SWIG_fail;
35077 arg4->Add(*s);
35078 delete s;
35079 Py_DECREF(item);
35080 }
35081 }
35082 {
35083 PyThreadState* __tstate = wxPyBeginAllowThreads();
35084 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35085 wxPyEndAllowThreads(__tstate);
35086 if (PyErr_Occurred()) SWIG_fail;
35087 }
35088 {
35089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35090 }
35091 {
35092 if (temp4) delete arg4;
35093 }
35094 return resultobj;
35095 fail:
35096 {
35097 if (temp4) delete arg4;
35098 }
35099 return NULL;
35100 }
35101
35102
35103 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35104 PyObject *resultobj = 0;
35105 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35106 int arg2 ;
35107 int arg3 ;
35108 wxDragResult arg4 ;
35109 wxDragResult result;
35110 void *argp1 = 0 ;
35111 int res1 = 0 ;
35112 int val2 ;
35113 int ecode2 = 0 ;
35114 int val3 ;
35115 int ecode3 = 0 ;
35116 int val4 ;
35117 int ecode4 = 0 ;
35118 PyObject * obj0 = 0 ;
35119 PyObject * obj1 = 0 ;
35120 PyObject * obj2 = 0 ;
35121 PyObject * obj3 = 0 ;
35122 char * kwnames[] = {
35123 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35124 };
35125
35126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35128 if (!SWIG_IsOK(res1)) {
35129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35130 }
35131 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35132 ecode2 = SWIG_AsVal_int(obj1, &val2);
35133 if (!SWIG_IsOK(ecode2)) {
35134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35135 }
35136 arg2 = static_cast< int >(val2);
35137 ecode3 = SWIG_AsVal_int(obj2, &val3);
35138 if (!SWIG_IsOK(ecode3)) {
35139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35140 }
35141 arg3 = static_cast< int >(val3);
35142 ecode4 = SWIG_AsVal_int(obj3, &val4);
35143 if (!SWIG_IsOK(ecode4)) {
35144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35145 }
35146 arg4 = static_cast< wxDragResult >(val4);
35147 {
35148 PyThreadState* __tstate = wxPyBeginAllowThreads();
35149 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35150 wxPyEndAllowThreads(__tstate);
35151 if (PyErr_Occurred()) SWIG_fail;
35152 }
35153 resultobj = SWIG_From_int(static_cast< int >(result));
35154 return resultobj;
35155 fail:
35156 return NULL;
35157 }
35158
35159
35160 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35161 PyObject *resultobj = 0;
35162 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35163 int arg2 ;
35164 int arg3 ;
35165 wxDragResult arg4 ;
35166 wxDragResult result;
35167 void *argp1 = 0 ;
35168 int res1 = 0 ;
35169 int val2 ;
35170 int ecode2 = 0 ;
35171 int val3 ;
35172 int ecode3 = 0 ;
35173 int val4 ;
35174 int ecode4 = 0 ;
35175 PyObject * obj0 = 0 ;
35176 PyObject * obj1 = 0 ;
35177 PyObject * obj2 = 0 ;
35178 PyObject * obj3 = 0 ;
35179 char * kwnames[] = {
35180 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35181 };
35182
35183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35185 if (!SWIG_IsOK(res1)) {
35186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35187 }
35188 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35189 ecode2 = SWIG_AsVal_int(obj1, &val2);
35190 if (!SWIG_IsOK(ecode2)) {
35191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35192 }
35193 arg2 = static_cast< int >(val2);
35194 ecode3 = SWIG_AsVal_int(obj2, &val3);
35195 if (!SWIG_IsOK(ecode3)) {
35196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35197 }
35198 arg3 = static_cast< int >(val3);
35199 ecode4 = SWIG_AsVal_int(obj3, &val4);
35200 if (!SWIG_IsOK(ecode4)) {
35201 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35202 }
35203 arg4 = static_cast< wxDragResult >(val4);
35204 {
35205 PyThreadState* __tstate = wxPyBeginAllowThreads();
35206 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35207 wxPyEndAllowThreads(__tstate);
35208 if (PyErr_Occurred()) SWIG_fail;
35209 }
35210 resultobj = SWIG_From_int(static_cast< int >(result));
35211 return resultobj;
35212 fail:
35213 return NULL;
35214 }
35215
35216
35217 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35218 PyObject *resultobj = 0;
35219 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35220 void *argp1 = 0 ;
35221 int res1 = 0 ;
35222 PyObject *swig_obj[1] ;
35223
35224 if (!args) SWIG_fail;
35225 swig_obj[0] = args;
35226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35227 if (!SWIG_IsOK(res1)) {
35228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35229 }
35230 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35231 {
35232 PyThreadState* __tstate = wxPyBeginAllowThreads();
35233 (arg1)->OnLeave();
35234 wxPyEndAllowThreads(__tstate);
35235 if (PyErr_Occurred()) SWIG_fail;
35236 }
35237 resultobj = SWIG_Py_Void();
35238 return resultobj;
35239 fail:
35240 return NULL;
35241 }
35242
35243
35244 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35245 PyObject *resultobj = 0;
35246 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35247 int arg2 ;
35248 int arg3 ;
35249 bool result;
35250 void *argp1 = 0 ;
35251 int res1 = 0 ;
35252 int val2 ;
35253 int ecode2 = 0 ;
35254 int val3 ;
35255 int ecode3 = 0 ;
35256 PyObject * obj0 = 0 ;
35257 PyObject * obj1 = 0 ;
35258 PyObject * obj2 = 0 ;
35259 char * kwnames[] = {
35260 (char *) "self",(char *) "x",(char *) "y", NULL
35261 };
35262
35263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35265 if (!SWIG_IsOK(res1)) {
35266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35267 }
35268 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35269 ecode2 = SWIG_AsVal_int(obj1, &val2);
35270 if (!SWIG_IsOK(ecode2)) {
35271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35272 }
35273 arg2 = static_cast< int >(val2);
35274 ecode3 = SWIG_AsVal_int(obj2, &val3);
35275 if (!SWIG_IsOK(ecode3)) {
35276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35277 }
35278 arg3 = static_cast< int >(val3);
35279 {
35280 PyThreadState* __tstate = wxPyBeginAllowThreads();
35281 result = (bool)(arg1)->OnDrop(arg2,arg3);
35282 wxPyEndAllowThreads(__tstate);
35283 if (PyErr_Occurred()) SWIG_fail;
35284 }
35285 {
35286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35287 }
35288 return resultobj;
35289 fail:
35290 return NULL;
35291 }
35292
35293
35294 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35295 PyObject *resultobj = 0;
35296 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35297 int arg2 ;
35298 int arg3 ;
35299 wxDragResult arg4 ;
35300 wxDragResult result;
35301 void *argp1 = 0 ;
35302 int res1 = 0 ;
35303 int val2 ;
35304 int ecode2 = 0 ;
35305 int val3 ;
35306 int ecode3 = 0 ;
35307 int val4 ;
35308 int ecode4 = 0 ;
35309 PyObject * obj0 = 0 ;
35310 PyObject * obj1 = 0 ;
35311 PyObject * obj2 = 0 ;
35312 PyObject * obj3 = 0 ;
35313 char * kwnames[] = {
35314 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35315 };
35316
35317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35319 if (!SWIG_IsOK(res1)) {
35320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35321 }
35322 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35323 ecode2 = SWIG_AsVal_int(obj1, &val2);
35324 if (!SWIG_IsOK(ecode2)) {
35325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35326 }
35327 arg2 = static_cast< int >(val2);
35328 ecode3 = SWIG_AsVal_int(obj2, &val3);
35329 if (!SWIG_IsOK(ecode3)) {
35330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35331 }
35332 arg3 = static_cast< int >(val3);
35333 ecode4 = SWIG_AsVal_int(obj3, &val4);
35334 if (!SWIG_IsOK(ecode4)) {
35335 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35336 }
35337 arg4 = static_cast< wxDragResult >(val4);
35338 {
35339 PyThreadState* __tstate = wxPyBeginAllowThreads();
35340 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35341 wxPyEndAllowThreads(__tstate);
35342 if (PyErr_Occurred()) SWIG_fail;
35343 }
35344 resultobj = SWIG_From_int(static_cast< int >(result));
35345 return resultobj;
35346 fail:
35347 return NULL;
35348 }
35349
35350
35351 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35352 PyObject *obj;
35353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35354 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35355 return SWIG_Py_Void();
35356 }
35357
35358 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35359 return SWIG_Python_InitShadowInstance(args);
35360 }
35361
35362 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35363 PyObject *resultobj = 0;
35364 wxClipboard *result = 0 ;
35365
35366 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35367 {
35368 PyThreadState* __tstate = wxPyBeginAllowThreads();
35369 result = (wxClipboard *)new wxClipboard();
35370 wxPyEndAllowThreads(__tstate);
35371 if (PyErr_Occurred()) SWIG_fail;
35372 }
35373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35374 return resultobj;
35375 fail:
35376 return NULL;
35377 }
35378
35379
35380 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35381 PyObject *resultobj = 0;
35382 wxClipboard *arg1 = (wxClipboard *) 0 ;
35383 void *argp1 = 0 ;
35384 int res1 = 0 ;
35385 PyObject *swig_obj[1] ;
35386
35387 if (!args) SWIG_fail;
35388 swig_obj[0] = args;
35389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35390 if (!SWIG_IsOK(res1)) {
35391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35392 }
35393 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35394 {
35395 PyThreadState* __tstate = wxPyBeginAllowThreads();
35396 delete arg1;
35397
35398 wxPyEndAllowThreads(__tstate);
35399 if (PyErr_Occurred()) SWIG_fail;
35400 }
35401 resultobj = SWIG_Py_Void();
35402 return resultobj;
35403 fail:
35404 return NULL;
35405 }
35406
35407
35408 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35409 PyObject *resultobj = 0;
35410 wxClipboard *arg1 = (wxClipboard *) 0 ;
35411 bool result;
35412 void *argp1 = 0 ;
35413 int res1 = 0 ;
35414 PyObject *swig_obj[1] ;
35415
35416 if (!args) SWIG_fail;
35417 swig_obj[0] = args;
35418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35419 if (!SWIG_IsOK(res1)) {
35420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35421 }
35422 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35423 {
35424 PyThreadState* __tstate = wxPyBeginAllowThreads();
35425 result = (bool)(arg1)->Open();
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 {
35430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35431 }
35432 return resultobj;
35433 fail:
35434 return NULL;
35435 }
35436
35437
35438 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35439 PyObject *resultobj = 0;
35440 wxClipboard *arg1 = (wxClipboard *) 0 ;
35441 void *argp1 = 0 ;
35442 int res1 = 0 ;
35443 PyObject *swig_obj[1] ;
35444
35445 if (!args) SWIG_fail;
35446 swig_obj[0] = args;
35447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35448 if (!SWIG_IsOK(res1)) {
35449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35450 }
35451 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35452 {
35453 PyThreadState* __tstate = wxPyBeginAllowThreads();
35454 (arg1)->Close();
35455 wxPyEndAllowThreads(__tstate);
35456 if (PyErr_Occurred()) SWIG_fail;
35457 }
35458 resultobj = SWIG_Py_Void();
35459 return resultobj;
35460 fail:
35461 return NULL;
35462 }
35463
35464
35465 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35466 PyObject *resultobj = 0;
35467 wxClipboard *arg1 = (wxClipboard *) 0 ;
35468 bool result;
35469 void *argp1 = 0 ;
35470 int res1 = 0 ;
35471 PyObject *swig_obj[1] ;
35472
35473 if (!args) SWIG_fail;
35474 swig_obj[0] = args;
35475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35476 if (!SWIG_IsOK(res1)) {
35477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35478 }
35479 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35480 {
35481 PyThreadState* __tstate = wxPyBeginAllowThreads();
35482 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35483 wxPyEndAllowThreads(__tstate);
35484 if (PyErr_Occurred()) SWIG_fail;
35485 }
35486 {
35487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35488 }
35489 return resultobj;
35490 fail:
35491 return NULL;
35492 }
35493
35494
35495 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35496 PyObject *resultobj = 0;
35497 wxClipboard *arg1 = (wxClipboard *) 0 ;
35498 wxDataObject *arg2 = (wxDataObject *) 0 ;
35499 bool result;
35500 void *argp1 = 0 ;
35501 int res1 = 0 ;
35502 int res2 = 0 ;
35503 PyObject * obj0 = 0 ;
35504 PyObject * obj1 = 0 ;
35505 char * kwnames[] = {
35506 (char *) "self",(char *) "data", NULL
35507 };
35508
35509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35511 if (!SWIG_IsOK(res1)) {
35512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35513 }
35514 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35515 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35516 if (!SWIG_IsOK(res2)) {
35517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35518 }
35519 {
35520 PyThreadState* __tstate = wxPyBeginAllowThreads();
35521 result = (bool)(arg1)->AddData(arg2);
35522 wxPyEndAllowThreads(__tstate);
35523 if (PyErr_Occurred()) SWIG_fail;
35524 }
35525 {
35526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35527 }
35528 return resultobj;
35529 fail:
35530 return NULL;
35531 }
35532
35533
35534 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35535 PyObject *resultobj = 0;
35536 wxClipboard *arg1 = (wxClipboard *) 0 ;
35537 wxDataObject *arg2 = (wxDataObject *) 0 ;
35538 bool result;
35539 void *argp1 = 0 ;
35540 int res1 = 0 ;
35541 int res2 = 0 ;
35542 PyObject * obj0 = 0 ;
35543 PyObject * obj1 = 0 ;
35544 char * kwnames[] = {
35545 (char *) "self",(char *) "data", NULL
35546 };
35547
35548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35550 if (!SWIG_IsOK(res1)) {
35551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35552 }
35553 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35554 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35555 if (!SWIG_IsOK(res2)) {
35556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35557 }
35558 {
35559 PyThreadState* __tstate = wxPyBeginAllowThreads();
35560 result = (bool)(arg1)->SetData(arg2);
35561 wxPyEndAllowThreads(__tstate);
35562 if (PyErr_Occurred()) SWIG_fail;
35563 }
35564 {
35565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35566 }
35567 return resultobj;
35568 fail:
35569 return NULL;
35570 }
35571
35572
35573 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35574 PyObject *resultobj = 0;
35575 wxClipboard *arg1 = (wxClipboard *) 0 ;
35576 wxDataFormat *arg2 = 0 ;
35577 bool result;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 void *argp2 = 0 ;
35581 int res2 = 0 ;
35582 PyObject * obj0 = 0 ;
35583 PyObject * obj1 = 0 ;
35584 char * kwnames[] = {
35585 (char *) "self",(char *) "format", NULL
35586 };
35587
35588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35590 if (!SWIG_IsOK(res1)) {
35591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35592 }
35593 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35595 if (!SWIG_IsOK(res2)) {
35596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35597 }
35598 if (!argp2) {
35599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35600 }
35601 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35602 {
35603 PyThreadState* __tstate = wxPyBeginAllowThreads();
35604 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
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_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35618 PyObject *resultobj = 0;
35619 wxClipboard *arg1 = (wxClipboard *) 0 ;
35620 wxDataObject *arg2 = 0 ;
35621 bool result;
35622 void *argp1 = 0 ;
35623 int res1 = 0 ;
35624 void *argp2 = 0 ;
35625 int res2 = 0 ;
35626 PyObject * obj0 = 0 ;
35627 PyObject * obj1 = 0 ;
35628 char * kwnames[] = {
35629 (char *) "self",(char *) "data", NULL
35630 };
35631
35632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35634 if (!SWIG_IsOK(res1)) {
35635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35636 }
35637 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35638 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35639 if (!SWIG_IsOK(res2)) {
35640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35641 }
35642 if (!argp2) {
35643 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35644 }
35645 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35646 {
35647 PyThreadState* __tstate = wxPyBeginAllowThreads();
35648 result = (bool)(arg1)->GetData(*arg2);
35649 wxPyEndAllowThreads(__tstate);
35650 if (PyErr_Occurred()) SWIG_fail;
35651 }
35652 {
35653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35654 }
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35662 PyObject *resultobj = 0;
35663 wxClipboard *arg1 = (wxClipboard *) 0 ;
35664 void *argp1 = 0 ;
35665 int res1 = 0 ;
35666 PyObject *swig_obj[1] ;
35667
35668 if (!args) SWIG_fail;
35669 swig_obj[0] = args;
35670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35671 if (!SWIG_IsOK(res1)) {
35672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35673 }
35674 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 (arg1)->Clear();
35678 wxPyEndAllowThreads(__tstate);
35679 if (PyErr_Occurred()) SWIG_fail;
35680 }
35681 resultobj = SWIG_Py_Void();
35682 return resultobj;
35683 fail:
35684 return NULL;
35685 }
35686
35687
35688 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35689 PyObject *resultobj = 0;
35690 wxClipboard *arg1 = (wxClipboard *) 0 ;
35691 bool result;
35692 void *argp1 = 0 ;
35693 int res1 = 0 ;
35694 PyObject *swig_obj[1] ;
35695
35696 if (!args) SWIG_fail;
35697 swig_obj[0] = args;
35698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35699 if (!SWIG_IsOK(res1)) {
35700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35701 }
35702 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35703 {
35704 PyThreadState* __tstate = wxPyBeginAllowThreads();
35705 result = (bool)(arg1)->Flush();
35706 wxPyEndAllowThreads(__tstate);
35707 if (PyErr_Occurred()) SWIG_fail;
35708 }
35709 {
35710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35711 }
35712 return resultobj;
35713 fail:
35714 return NULL;
35715 }
35716
35717
35718 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35719 PyObject *resultobj = 0;
35720 wxClipboard *arg1 = (wxClipboard *) 0 ;
35721 bool arg2 = (bool) true ;
35722 void *argp1 = 0 ;
35723 int res1 = 0 ;
35724 bool val2 ;
35725 int ecode2 = 0 ;
35726 PyObject * obj0 = 0 ;
35727 PyObject * obj1 = 0 ;
35728 char * kwnames[] = {
35729 (char *) "self",(char *) "primary", NULL
35730 };
35731
35732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35734 if (!SWIG_IsOK(res1)) {
35735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35736 }
35737 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35738 if (obj1) {
35739 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35740 if (!SWIG_IsOK(ecode2)) {
35741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35742 }
35743 arg2 = static_cast< bool >(val2);
35744 }
35745 {
35746 PyThreadState* __tstate = wxPyBeginAllowThreads();
35747 (arg1)->UsePrimarySelection(arg2);
35748 wxPyEndAllowThreads(__tstate);
35749 if (PyErr_Occurred()) SWIG_fail;
35750 }
35751 resultobj = SWIG_Py_Void();
35752 return resultobj;
35753 fail:
35754 return NULL;
35755 }
35756
35757
35758 SWIGINTERN PyObject *_wrap_Clipboard_IsUsingPrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35759 PyObject *resultobj = 0;
35760 wxClipboard *arg1 = (wxClipboard *) 0 ;
35761 bool result;
35762 void *argp1 = 0 ;
35763 int res1 = 0 ;
35764 PyObject *swig_obj[1] ;
35765
35766 if (!args) SWIG_fail;
35767 swig_obj[0] = args;
35768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35769 if (!SWIG_IsOK(res1)) {
35770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsUsingPrimarySelection" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35771 }
35772 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35773 {
35774 PyThreadState* __tstate = wxPyBeginAllowThreads();
35775 result = (bool)((wxClipboard const *)arg1)->IsUsingPrimarySelection();
35776 wxPyEndAllowThreads(__tstate);
35777 if (PyErr_Occurred()) SWIG_fail;
35778 }
35779 {
35780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35781 }
35782 return resultobj;
35783 fail:
35784 return NULL;
35785 }
35786
35787
35788 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35789 PyObject *resultobj = 0;
35790 wxClipboard *result = 0 ;
35791
35792 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35793 {
35794 PyThreadState* __tstate = wxPyBeginAllowThreads();
35795 result = (wxClipboard *)wxClipboard::Get();
35796 wxPyEndAllowThreads(__tstate);
35797 if (PyErr_Occurred()) SWIG_fail;
35798 }
35799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35800 return resultobj;
35801 fail:
35802 return NULL;
35803 }
35804
35805
35806 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35807 PyObject *obj;
35808 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35809 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35810 return SWIG_Py_Void();
35811 }
35812
35813 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35814 return SWIG_Python_InitShadowInstance(args);
35815 }
35816
35817 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35818 PyObject *resultobj = 0;
35819 wxClipboard *arg1 = (wxClipboard *) NULL ;
35820 wxClipboardLocker *result = 0 ;
35821 void *argp1 = 0 ;
35822 int res1 = 0 ;
35823 PyObject * obj0 = 0 ;
35824 char * kwnames[] = {
35825 (char *) "clipboard", NULL
35826 };
35827
35828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35829 if (obj0) {
35830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35831 if (!SWIG_IsOK(res1)) {
35832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35833 }
35834 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35835 }
35836 {
35837 PyThreadState* __tstate = wxPyBeginAllowThreads();
35838 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35839 wxPyEndAllowThreads(__tstate);
35840 if (PyErr_Occurred()) SWIG_fail;
35841 }
35842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35843 return resultobj;
35844 fail:
35845 return NULL;
35846 }
35847
35848
35849 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35850 PyObject *resultobj = 0;
35851 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35852 void *argp1 = 0 ;
35853 int res1 = 0 ;
35854 PyObject *swig_obj[1] ;
35855
35856 if (!args) SWIG_fail;
35857 swig_obj[0] = args;
35858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35859 if (!SWIG_IsOK(res1)) {
35860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35861 }
35862 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35863 {
35864 PyThreadState* __tstate = wxPyBeginAllowThreads();
35865 delete arg1;
35866
35867 wxPyEndAllowThreads(__tstate);
35868 if (PyErr_Occurred()) SWIG_fail;
35869 }
35870 resultobj = SWIG_Py_Void();
35871 return resultobj;
35872 fail:
35873 return NULL;
35874 }
35875
35876
35877 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35878 PyObject *resultobj = 0;
35879 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35880 bool result;
35881 void *argp1 = 0 ;
35882 int res1 = 0 ;
35883 PyObject *swig_obj[1] ;
35884
35885 if (!args) SWIG_fail;
35886 swig_obj[0] = args;
35887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35888 if (!SWIG_IsOK(res1)) {
35889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35890 }
35891 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35892 {
35893 PyThreadState* __tstate = wxPyBeginAllowThreads();
35894 result = (bool)wxClipboardLocker___nonzero__(arg1);
35895 wxPyEndAllowThreads(__tstate);
35896 if (PyErr_Occurred()) SWIG_fail;
35897 }
35898 {
35899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35900 }
35901 return resultobj;
35902 fail:
35903 return NULL;
35904 }
35905
35906
35907 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35908 PyObject *obj;
35909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35910 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35911 return SWIG_Py_Void();
35912 }
35913
35914 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35915 return SWIG_Python_InitShadowInstance(args);
35916 }
35917
35918 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35919 PyObject *resultobj = 0;
35920 int arg1 = (int) 0 ;
35921 int arg2 = (int) 0 ;
35922 int arg3 = (int) 0 ;
35923 int arg4 = (int) 0 ;
35924 wxVideoMode *result = 0 ;
35925 int val1 ;
35926 int ecode1 = 0 ;
35927 int val2 ;
35928 int ecode2 = 0 ;
35929 int val3 ;
35930 int ecode3 = 0 ;
35931 int val4 ;
35932 int ecode4 = 0 ;
35933 PyObject * obj0 = 0 ;
35934 PyObject * obj1 = 0 ;
35935 PyObject * obj2 = 0 ;
35936 PyObject * obj3 = 0 ;
35937 char * kwnames[] = {
35938 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35939 };
35940
35941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35942 if (obj0) {
35943 ecode1 = SWIG_AsVal_int(obj0, &val1);
35944 if (!SWIG_IsOK(ecode1)) {
35945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35946 }
35947 arg1 = static_cast< int >(val1);
35948 }
35949 if (obj1) {
35950 ecode2 = SWIG_AsVal_int(obj1, &val2);
35951 if (!SWIG_IsOK(ecode2)) {
35952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35953 }
35954 arg2 = static_cast< int >(val2);
35955 }
35956 if (obj2) {
35957 ecode3 = SWIG_AsVal_int(obj2, &val3);
35958 if (!SWIG_IsOK(ecode3)) {
35959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35960 }
35961 arg3 = static_cast< int >(val3);
35962 }
35963 if (obj3) {
35964 ecode4 = SWIG_AsVal_int(obj3, &val4);
35965 if (!SWIG_IsOK(ecode4)) {
35966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35967 }
35968 arg4 = static_cast< int >(val4);
35969 }
35970 {
35971 PyThreadState* __tstate = wxPyBeginAllowThreads();
35972 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35973 wxPyEndAllowThreads(__tstate);
35974 if (PyErr_Occurred()) SWIG_fail;
35975 }
35976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35977 return resultobj;
35978 fail:
35979 return NULL;
35980 }
35981
35982
35983 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35984 PyObject *resultobj = 0;
35985 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35986 void *argp1 = 0 ;
35987 int res1 = 0 ;
35988 PyObject *swig_obj[1] ;
35989
35990 if (!args) SWIG_fail;
35991 swig_obj[0] = args;
35992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35993 if (!SWIG_IsOK(res1)) {
35994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35995 }
35996 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35997 {
35998 PyThreadState* __tstate = wxPyBeginAllowThreads();
35999 delete arg1;
36000
36001 wxPyEndAllowThreads(__tstate);
36002 if (PyErr_Occurred()) SWIG_fail;
36003 }
36004 resultobj = SWIG_Py_Void();
36005 return resultobj;
36006 fail:
36007 return NULL;
36008 }
36009
36010
36011 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36012 PyObject *resultobj = 0;
36013 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36014 wxVideoMode *arg2 = 0 ;
36015 bool result;
36016 void *argp1 = 0 ;
36017 int res1 = 0 ;
36018 void *argp2 = 0 ;
36019 int res2 = 0 ;
36020 PyObject * obj0 = 0 ;
36021 PyObject * obj1 = 0 ;
36022 char * kwnames[] = {
36023 (char *) "self",(char *) "other", NULL
36024 };
36025
36026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
36027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36028 if (!SWIG_IsOK(res1)) {
36029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36030 }
36031 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36032 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36033 if (!SWIG_IsOK(res2)) {
36034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36035 }
36036 if (!argp2) {
36037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36038 }
36039 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36040 {
36041 PyThreadState* __tstate = wxPyBeginAllowThreads();
36042 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
36043 wxPyEndAllowThreads(__tstate);
36044 if (PyErr_Occurred()) SWIG_fail;
36045 }
36046 {
36047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36048 }
36049 return resultobj;
36050 fail:
36051 return NULL;
36052 }
36053
36054
36055 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36056 PyObject *resultobj = 0;
36057 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36058 int result;
36059 void *argp1 = 0 ;
36060 int res1 = 0 ;
36061 PyObject *swig_obj[1] ;
36062
36063 if (!args) SWIG_fail;
36064 swig_obj[0] = args;
36065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36066 if (!SWIG_IsOK(res1)) {
36067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36068 }
36069 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36070 {
36071 PyThreadState* __tstate = wxPyBeginAllowThreads();
36072 result = (int)((wxVideoMode const *)arg1)->GetWidth();
36073 wxPyEndAllowThreads(__tstate);
36074 if (PyErr_Occurred()) SWIG_fail;
36075 }
36076 resultobj = SWIG_From_int(static_cast< int >(result));
36077 return resultobj;
36078 fail:
36079 return NULL;
36080 }
36081
36082
36083 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36084 PyObject *resultobj = 0;
36085 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36086 int result;
36087 void *argp1 = 0 ;
36088 int res1 = 0 ;
36089 PyObject *swig_obj[1] ;
36090
36091 if (!args) SWIG_fail;
36092 swig_obj[0] = args;
36093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36094 if (!SWIG_IsOK(res1)) {
36095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36096 }
36097 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36098 {
36099 PyThreadState* __tstate = wxPyBeginAllowThreads();
36100 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36101 wxPyEndAllowThreads(__tstate);
36102 if (PyErr_Occurred()) SWIG_fail;
36103 }
36104 resultobj = SWIG_From_int(static_cast< int >(result));
36105 return resultobj;
36106 fail:
36107 return NULL;
36108 }
36109
36110
36111 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36112 PyObject *resultobj = 0;
36113 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36114 int result;
36115 void *argp1 = 0 ;
36116 int res1 = 0 ;
36117 PyObject *swig_obj[1] ;
36118
36119 if (!args) SWIG_fail;
36120 swig_obj[0] = args;
36121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36122 if (!SWIG_IsOK(res1)) {
36123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36124 }
36125 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36126 {
36127 PyThreadState* __tstate = wxPyBeginAllowThreads();
36128 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36129 wxPyEndAllowThreads(__tstate);
36130 if (PyErr_Occurred()) SWIG_fail;
36131 }
36132 resultobj = SWIG_From_int(static_cast< int >(result));
36133 return resultobj;
36134 fail:
36135 return NULL;
36136 }
36137
36138
36139 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36140 PyObject *resultobj = 0;
36141 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36142 bool result;
36143 void *argp1 = 0 ;
36144 int res1 = 0 ;
36145 PyObject *swig_obj[1] ;
36146
36147 if (!args) SWIG_fail;
36148 swig_obj[0] = args;
36149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36150 if (!SWIG_IsOK(res1)) {
36151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36152 }
36153 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36154 {
36155 PyThreadState* __tstate = wxPyBeginAllowThreads();
36156 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36157 wxPyEndAllowThreads(__tstate);
36158 if (PyErr_Occurred()) SWIG_fail;
36159 }
36160 {
36161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36162 }
36163 return resultobj;
36164 fail:
36165 return NULL;
36166 }
36167
36168
36169 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36170 PyObject *resultobj = 0;
36171 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36172 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36173 bool result;
36174 void *argp1 = 0 ;
36175 int res1 = 0 ;
36176 void *argp2 = 0 ;
36177 int res2 = 0 ;
36178 PyObject * obj0 = 0 ;
36179 PyObject * obj1 = 0 ;
36180 char * kwnames[] = {
36181 (char *) "self",(char *) "other", NULL
36182 };
36183
36184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36186 if (!SWIG_IsOK(res1)) {
36187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36188 }
36189 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36191 if (!SWIG_IsOK(res2)) {
36192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36193 }
36194 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36195 {
36196 PyThreadState* __tstate = wxPyBeginAllowThreads();
36197 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36198 wxPyEndAllowThreads(__tstate);
36199 if (PyErr_Occurred()) SWIG_fail;
36200 }
36201 {
36202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36203 }
36204 return resultobj;
36205 fail:
36206 return NULL;
36207 }
36208
36209
36210 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36211 PyObject *resultobj = 0;
36212 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36213 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36214 bool result;
36215 void *argp1 = 0 ;
36216 int res1 = 0 ;
36217 void *argp2 = 0 ;
36218 int res2 = 0 ;
36219 PyObject * obj0 = 0 ;
36220 PyObject * obj1 = 0 ;
36221 char * kwnames[] = {
36222 (char *) "self",(char *) "other", NULL
36223 };
36224
36225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36227 if (!SWIG_IsOK(res1)) {
36228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36229 }
36230 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36231 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36232 if (!SWIG_IsOK(res2)) {
36233 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36234 }
36235 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36236 {
36237 PyThreadState* __tstate = wxPyBeginAllowThreads();
36238 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36239 wxPyEndAllowThreads(__tstate);
36240 if (PyErr_Occurred()) SWIG_fail;
36241 }
36242 {
36243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36244 }
36245 return resultobj;
36246 fail:
36247 return NULL;
36248 }
36249
36250
36251 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36252 PyObject *resultobj = 0;
36253 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36254 int arg2 ;
36255 void *argp1 = 0 ;
36256 int res1 = 0 ;
36257 int val2 ;
36258 int ecode2 = 0 ;
36259 PyObject *swig_obj[2] ;
36260
36261 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36263 if (!SWIG_IsOK(res1)) {
36264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36265 }
36266 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36267 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36268 if (!SWIG_IsOK(ecode2)) {
36269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36270 }
36271 arg2 = static_cast< int >(val2);
36272 if (arg1) (arg1)->w = arg2;
36273
36274 resultobj = SWIG_Py_Void();
36275 return resultobj;
36276 fail:
36277 return NULL;
36278 }
36279
36280
36281 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36282 PyObject *resultobj = 0;
36283 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36284 int result;
36285 void *argp1 = 0 ;
36286 int res1 = 0 ;
36287 PyObject *swig_obj[1] ;
36288
36289 if (!args) SWIG_fail;
36290 swig_obj[0] = args;
36291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36292 if (!SWIG_IsOK(res1)) {
36293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36294 }
36295 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36296 result = (int) ((arg1)->w);
36297 resultobj = SWIG_From_int(static_cast< int >(result));
36298 return resultobj;
36299 fail:
36300 return NULL;
36301 }
36302
36303
36304 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36305 PyObject *resultobj = 0;
36306 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36307 int arg2 ;
36308 void *argp1 = 0 ;
36309 int res1 = 0 ;
36310 int val2 ;
36311 int ecode2 = 0 ;
36312 PyObject *swig_obj[2] ;
36313
36314 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36316 if (!SWIG_IsOK(res1)) {
36317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36318 }
36319 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36320 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36321 if (!SWIG_IsOK(ecode2)) {
36322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36323 }
36324 arg2 = static_cast< int >(val2);
36325 if (arg1) (arg1)->h = arg2;
36326
36327 resultobj = SWIG_Py_Void();
36328 return resultobj;
36329 fail:
36330 return NULL;
36331 }
36332
36333
36334 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36335 PyObject *resultobj = 0;
36336 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36337 int result;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 PyObject *swig_obj[1] ;
36341
36342 if (!args) SWIG_fail;
36343 swig_obj[0] = args;
36344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36345 if (!SWIG_IsOK(res1)) {
36346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36347 }
36348 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36349 result = (int) ((arg1)->h);
36350 resultobj = SWIG_From_int(static_cast< int >(result));
36351 return resultobj;
36352 fail:
36353 return NULL;
36354 }
36355
36356
36357 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36358 PyObject *resultobj = 0;
36359 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36360 int arg2 ;
36361 void *argp1 = 0 ;
36362 int res1 = 0 ;
36363 int val2 ;
36364 int ecode2 = 0 ;
36365 PyObject *swig_obj[2] ;
36366
36367 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36369 if (!SWIG_IsOK(res1)) {
36370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36371 }
36372 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36373 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36374 if (!SWIG_IsOK(ecode2)) {
36375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36376 }
36377 arg2 = static_cast< int >(val2);
36378 if (arg1) (arg1)->bpp = arg2;
36379
36380 resultobj = SWIG_Py_Void();
36381 return resultobj;
36382 fail:
36383 return NULL;
36384 }
36385
36386
36387 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36388 PyObject *resultobj = 0;
36389 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36390 int result;
36391 void *argp1 = 0 ;
36392 int res1 = 0 ;
36393 PyObject *swig_obj[1] ;
36394
36395 if (!args) SWIG_fail;
36396 swig_obj[0] = args;
36397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36398 if (!SWIG_IsOK(res1)) {
36399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36400 }
36401 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36402 result = (int) ((arg1)->bpp);
36403 resultobj = SWIG_From_int(static_cast< int >(result));
36404 return resultobj;
36405 fail:
36406 return NULL;
36407 }
36408
36409
36410 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36411 PyObject *resultobj = 0;
36412 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36413 int arg2 ;
36414 void *argp1 = 0 ;
36415 int res1 = 0 ;
36416 int val2 ;
36417 int ecode2 = 0 ;
36418 PyObject *swig_obj[2] ;
36419
36420 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36422 if (!SWIG_IsOK(res1)) {
36423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36424 }
36425 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36426 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36427 if (!SWIG_IsOK(ecode2)) {
36428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36429 }
36430 arg2 = static_cast< int >(val2);
36431 if (arg1) (arg1)->refresh = arg2;
36432
36433 resultobj = SWIG_Py_Void();
36434 return resultobj;
36435 fail:
36436 return NULL;
36437 }
36438
36439
36440 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36441 PyObject *resultobj = 0;
36442 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36443 int result;
36444 void *argp1 = 0 ;
36445 int res1 = 0 ;
36446 PyObject *swig_obj[1] ;
36447
36448 if (!args) SWIG_fail;
36449 swig_obj[0] = args;
36450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36451 if (!SWIG_IsOK(res1)) {
36452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36453 }
36454 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36455 result = (int) ((arg1)->refresh);
36456 resultobj = SWIG_From_int(static_cast< int >(result));
36457 return resultobj;
36458 fail:
36459 return NULL;
36460 }
36461
36462
36463 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36464 PyObject *obj;
36465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36466 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36467 return SWIG_Py_Void();
36468 }
36469
36470 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36471 return SWIG_Python_InitShadowInstance(args);
36472 }
36473
36474 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36475 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36476 return 1;
36477 }
36478
36479
36480 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36481 PyObject *pyobj = 0;
36482
36483 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36484 return pyobj;
36485 }
36486
36487
36488 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36489 PyObject *resultobj = 0;
36490 unsigned int arg1 = (unsigned int) 0 ;
36491 wxDisplay *result = 0 ;
36492 unsigned int val1 ;
36493 int ecode1 = 0 ;
36494 PyObject * obj0 = 0 ;
36495 char * kwnames[] = {
36496 (char *) "index", NULL
36497 };
36498
36499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36500 if (obj0) {
36501 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36502 if (!SWIG_IsOK(ecode1)) {
36503 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36504 }
36505 arg1 = static_cast< unsigned int >(val1);
36506 }
36507 {
36508 PyThreadState* __tstate = wxPyBeginAllowThreads();
36509 result = (wxDisplay *)new wxDisplay(arg1);
36510 wxPyEndAllowThreads(__tstate);
36511 if (PyErr_Occurred()) SWIG_fail;
36512 }
36513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36521 PyObject *resultobj = 0;
36522 wxDisplay *arg1 = (wxDisplay *) 0 ;
36523 void *argp1 = 0 ;
36524 int res1 = 0 ;
36525 PyObject *swig_obj[1] ;
36526
36527 if (!args) SWIG_fail;
36528 swig_obj[0] = args;
36529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36530 if (!SWIG_IsOK(res1)) {
36531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36532 }
36533 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36534 {
36535 PyThreadState* __tstate = wxPyBeginAllowThreads();
36536 delete arg1;
36537
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 resultobj = SWIG_Py_Void();
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36549 PyObject *resultobj = 0;
36550 unsigned int result;
36551
36552 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36553 {
36554 PyThreadState* __tstate = wxPyBeginAllowThreads();
36555 result = (unsigned int)wxDisplay::GetCount();
36556 wxPyEndAllowThreads(__tstate);
36557 if (PyErr_Occurred()) SWIG_fail;
36558 }
36559 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36560 return resultobj;
36561 fail:
36562 return NULL;
36563 }
36564
36565
36566 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36567 PyObject *resultobj = 0;
36568 wxPoint *arg1 = 0 ;
36569 int result;
36570 wxPoint temp1 ;
36571 PyObject * obj0 = 0 ;
36572 char * kwnames[] = {
36573 (char *) "pt", NULL
36574 };
36575
36576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36577 {
36578 arg1 = &temp1;
36579 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36580 }
36581 {
36582 PyThreadState* __tstate = wxPyBeginAllowThreads();
36583 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36584 wxPyEndAllowThreads(__tstate);
36585 if (PyErr_Occurred()) SWIG_fail;
36586 }
36587 resultobj = SWIG_From_int(static_cast< int >(result));
36588 return resultobj;
36589 fail:
36590 return NULL;
36591 }
36592
36593
36594 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36595 PyObject *resultobj = 0;
36596 wxWindow *arg1 = (wxWindow *) 0 ;
36597 int result;
36598 void *argp1 = 0 ;
36599 int res1 = 0 ;
36600 PyObject * obj0 = 0 ;
36601 char * kwnames[] = {
36602 (char *) "window", NULL
36603 };
36604
36605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36607 if (!SWIG_IsOK(res1)) {
36608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow const *""'");
36609 }
36610 arg1 = reinterpret_cast< wxWindow * >(argp1);
36611 {
36612 PyThreadState* __tstate = wxPyBeginAllowThreads();
36613 result = (int)wxDisplay::GetFromWindow((wxWindow const *)arg1);
36614 wxPyEndAllowThreads(__tstate);
36615 if (PyErr_Occurred()) SWIG_fail;
36616 }
36617 resultobj = SWIG_From_int(static_cast< int >(result));
36618 return resultobj;
36619 fail:
36620 return NULL;
36621 }
36622
36623
36624 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36625 PyObject *resultobj = 0;
36626 wxDisplay *arg1 = (wxDisplay *) 0 ;
36627 bool result;
36628 void *argp1 = 0 ;
36629 int res1 = 0 ;
36630 PyObject *swig_obj[1] ;
36631
36632 if (!args) SWIG_fail;
36633 swig_obj[0] = args;
36634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36635 if (!SWIG_IsOK(res1)) {
36636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36637 }
36638 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36639 {
36640 PyThreadState* __tstate = wxPyBeginAllowThreads();
36641 result = (bool)((wxDisplay const *)arg1)->IsOk();
36642 wxPyEndAllowThreads(__tstate);
36643 if (PyErr_Occurred()) SWIG_fail;
36644 }
36645 {
36646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36647 }
36648 return resultobj;
36649 fail:
36650 return NULL;
36651 }
36652
36653
36654 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36655 PyObject *resultobj = 0;
36656 wxDisplay *arg1 = (wxDisplay *) 0 ;
36657 wxRect result;
36658 void *argp1 = 0 ;
36659 int res1 = 0 ;
36660 PyObject *swig_obj[1] ;
36661
36662 if (!args) SWIG_fail;
36663 swig_obj[0] = args;
36664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36665 if (!SWIG_IsOK(res1)) {
36666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36667 }
36668 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36669 {
36670 PyThreadState* __tstate = wxPyBeginAllowThreads();
36671 result = ((wxDisplay const *)arg1)->GetGeometry();
36672 wxPyEndAllowThreads(__tstate);
36673 if (PyErr_Occurred()) SWIG_fail;
36674 }
36675 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36676 return resultobj;
36677 fail:
36678 return NULL;
36679 }
36680
36681
36682 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36683 PyObject *resultobj = 0;
36684 wxDisplay *arg1 = (wxDisplay *) 0 ;
36685 wxRect result;
36686 void *argp1 = 0 ;
36687 int res1 = 0 ;
36688 PyObject *swig_obj[1] ;
36689
36690 if (!args) SWIG_fail;
36691 swig_obj[0] = args;
36692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36693 if (!SWIG_IsOK(res1)) {
36694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36695 }
36696 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36697 {
36698 PyThreadState* __tstate = wxPyBeginAllowThreads();
36699 result = ((wxDisplay const *)arg1)->GetClientArea();
36700 wxPyEndAllowThreads(__tstate);
36701 if (PyErr_Occurred()) SWIG_fail;
36702 }
36703 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36704 return resultobj;
36705 fail:
36706 return NULL;
36707 }
36708
36709
36710 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36711 PyObject *resultobj = 0;
36712 wxDisplay *arg1 = (wxDisplay *) 0 ;
36713 wxString result;
36714 void *argp1 = 0 ;
36715 int res1 = 0 ;
36716 PyObject *swig_obj[1] ;
36717
36718 if (!args) SWIG_fail;
36719 swig_obj[0] = args;
36720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36721 if (!SWIG_IsOK(res1)) {
36722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36723 }
36724 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36725 {
36726 PyThreadState* __tstate = wxPyBeginAllowThreads();
36727 result = ((wxDisplay const *)arg1)->GetName();
36728 wxPyEndAllowThreads(__tstate);
36729 if (PyErr_Occurred()) SWIG_fail;
36730 }
36731 {
36732 #if wxUSE_UNICODE
36733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36734 #else
36735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36736 #endif
36737 }
36738 return resultobj;
36739 fail:
36740 return NULL;
36741 }
36742
36743
36744 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36745 PyObject *resultobj = 0;
36746 wxDisplay *arg1 = (wxDisplay *) 0 ;
36747 bool result;
36748 void *argp1 = 0 ;
36749 int res1 = 0 ;
36750 PyObject *swig_obj[1] ;
36751
36752 if (!args) SWIG_fail;
36753 swig_obj[0] = args;
36754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36755 if (!SWIG_IsOK(res1)) {
36756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36757 }
36758 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36759 {
36760 PyThreadState* __tstate = wxPyBeginAllowThreads();
36761 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36762 wxPyEndAllowThreads(__tstate);
36763 if (PyErr_Occurred()) SWIG_fail;
36764 }
36765 {
36766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36767 }
36768 return resultobj;
36769 fail:
36770 return NULL;
36771 }
36772
36773
36774 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36775 PyObject *resultobj = 0;
36776 wxDisplay *arg1 = (wxDisplay *) 0 ;
36777 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36778 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36779 PyObject *result = 0 ;
36780 void *argp1 = 0 ;
36781 int res1 = 0 ;
36782 void *argp2 = 0 ;
36783 int res2 = 0 ;
36784 PyObject * obj0 = 0 ;
36785 PyObject * obj1 = 0 ;
36786 char * kwnames[] = {
36787 (char *) "self",(char *) "mode", NULL
36788 };
36789
36790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36792 if (!SWIG_IsOK(res1)) {
36793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36794 }
36795 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36796 if (obj1) {
36797 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36798 if (!SWIG_IsOK(res2)) {
36799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36800 }
36801 if (!argp2) {
36802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36803 }
36804 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36805 }
36806 {
36807 PyThreadState* __tstate = wxPyBeginAllowThreads();
36808 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36809 wxPyEndAllowThreads(__tstate);
36810 if (PyErr_Occurred()) SWIG_fail;
36811 }
36812 resultobj = result;
36813 return resultobj;
36814 fail:
36815 return NULL;
36816 }
36817
36818
36819 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36820 PyObject *resultobj = 0;
36821 wxDisplay *arg1 = (wxDisplay *) 0 ;
36822 wxVideoMode 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_wxDisplay, 0 | 0 );
36830 if (!SWIG_IsOK(res1)) {
36831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36832 }
36833 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36834 {
36835 PyThreadState* __tstate = wxPyBeginAllowThreads();
36836 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36837 wxPyEndAllowThreads(__tstate);
36838 if (PyErr_Occurred()) SWIG_fail;
36839 }
36840 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36841 return resultobj;
36842 fail:
36843 return NULL;
36844 }
36845
36846
36847 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36848 PyObject *resultobj = 0;
36849 wxDisplay *arg1 = (wxDisplay *) 0 ;
36850 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36851 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36852 bool result;
36853 void *argp1 = 0 ;
36854 int res1 = 0 ;
36855 void *argp2 = 0 ;
36856 int res2 = 0 ;
36857 PyObject * obj0 = 0 ;
36858 PyObject * obj1 = 0 ;
36859 char * kwnames[] = {
36860 (char *) "self",(char *) "mode", NULL
36861 };
36862
36863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36865 if (!SWIG_IsOK(res1)) {
36866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36867 }
36868 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36869 if (obj1) {
36870 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36871 if (!SWIG_IsOK(res2)) {
36872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36873 }
36874 if (!argp2) {
36875 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36876 }
36877 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36878 }
36879 {
36880 PyThreadState* __tstate = wxPyBeginAllowThreads();
36881 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36882 wxPyEndAllowThreads(__tstate);
36883 if (PyErr_Occurred()) SWIG_fail;
36884 }
36885 {
36886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36887 }
36888 return resultobj;
36889 fail:
36890 return NULL;
36891 }
36892
36893
36894 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36895 PyObject *resultobj = 0;
36896 wxDisplay *arg1 = (wxDisplay *) 0 ;
36897 void *argp1 = 0 ;
36898 int res1 = 0 ;
36899 PyObject *swig_obj[1] ;
36900
36901 if (!args) SWIG_fail;
36902 swig_obj[0] = args;
36903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36904 if (!SWIG_IsOK(res1)) {
36905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36906 }
36907 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36908 {
36909 PyThreadState* __tstate = wxPyBeginAllowThreads();
36910 wxDisplay_ResetMode(arg1);
36911 wxPyEndAllowThreads(__tstate);
36912 if (PyErr_Occurred()) SWIG_fail;
36913 }
36914 resultobj = SWIG_Py_Void();
36915 return resultobj;
36916 fail:
36917 return NULL;
36918 }
36919
36920
36921 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36922 PyObject *obj;
36923 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36924 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36925 return SWIG_Py_Void();
36926 }
36927
36928 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36929 return SWIG_Python_InitShadowInstance(args);
36930 }
36931
36932 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36933 PyObject *resultobj = 0;
36934 wxStandardPaths *result = 0 ;
36935
36936 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36937 {
36938 PyThreadState* __tstate = wxPyBeginAllowThreads();
36939 result = (wxStandardPaths *)wxStandardPaths_Get();
36940 wxPyEndAllowThreads(__tstate);
36941 if (PyErr_Occurred()) SWIG_fail;
36942 }
36943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36944 return resultobj;
36945 fail:
36946 return NULL;
36947 }
36948
36949
36950 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36951 PyObject *resultobj = 0;
36952 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36953 wxString result;
36954 void *argp1 = 0 ;
36955 int res1 = 0 ;
36956 PyObject *swig_obj[1] ;
36957
36958 if (!args) SWIG_fail;
36959 swig_obj[0] = args;
36960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36961 if (!SWIG_IsOK(res1)) {
36962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36963 }
36964 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36965 {
36966 PyThreadState* __tstate = wxPyBeginAllowThreads();
36967 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36968 wxPyEndAllowThreads(__tstate);
36969 if (PyErr_Occurred()) SWIG_fail;
36970 }
36971 {
36972 #if wxUSE_UNICODE
36973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36974 #else
36975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36976 #endif
36977 }
36978 return resultobj;
36979 fail:
36980 return NULL;
36981 }
36982
36983
36984 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36985 PyObject *resultobj = 0;
36986 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36987 wxString result;
36988 void *argp1 = 0 ;
36989 int res1 = 0 ;
36990 PyObject *swig_obj[1] ;
36991
36992 if (!args) SWIG_fail;
36993 swig_obj[0] = args;
36994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36995 if (!SWIG_IsOK(res1)) {
36996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36997 }
36998 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36999 {
37000 PyThreadState* __tstate = wxPyBeginAllowThreads();
37001 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
37002 wxPyEndAllowThreads(__tstate);
37003 if (PyErr_Occurred()) SWIG_fail;
37004 }
37005 {
37006 #if wxUSE_UNICODE
37007 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37008 #else
37009 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37010 #endif
37011 }
37012 return resultobj;
37013 fail:
37014 return NULL;
37015 }
37016
37017
37018 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37019 PyObject *resultobj = 0;
37020 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37021 wxString result;
37022 void *argp1 = 0 ;
37023 int res1 = 0 ;
37024 PyObject *swig_obj[1] ;
37025
37026 if (!args) SWIG_fail;
37027 swig_obj[0] = args;
37028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37029 if (!SWIG_IsOK(res1)) {
37030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37031 }
37032 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37033 {
37034 PyThreadState* __tstate = wxPyBeginAllowThreads();
37035 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
37036 wxPyEndAllowThreads(__tstate);
37037 if (PyErr_Occurred()) SWIG_fail;
37038 }
37039 {
37040 #if wxUSE_UNICODE
37041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37042 #else
37043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37044 #endif
37045 }
37046 return resultobj;
37047 fail:
37048 return NULL;
37049 }
37050
37051
37052 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37053 PyObject *resultobj = 0;
37054 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37055 wxString result;
37056 void *argp1 = 0 ;
37057 int res1 = 0 ;
37058 PyObject *swig_obj[1] ;
37059
37060 if (!args) SWIG_fail;
37061 swig_obj[0] = args;
37062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37063 if (!SWIG_IsOK(res1)) {
37064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37065 }
37066 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37067 {
37068 PyThreadState* __tstate = wxPyBeginAllowThreads();
37069 result = ((wxStandardPaths const *)arg1)->GetDataDir();
37070 wxPyEndAllowThreads(__tstate);
37071 if (PyErr_Occurred()) SWIG_fail;
37072 }
37073 {
37074 #if wxUSE_UNICODE
37075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37076 #else
37077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37078 #endif
37079 }
37080 return resultobj;
37081 fail:
37082 return NULL;
37083 }
37084
37085
37086 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37087 PyObject *resultobj = 0;
37088 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37089 wxString result;
37090 void *argp1 = 0 ;
37091 int res1 = 0 ;
37092 PyObject *swig_obj[1] ;
37093
37094 if (!args) SWIG_fail;
37095 swig_obj[0] = args;
37096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37097 if (!SWIG_IsOK(res1)) {
37098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37099 }
37100 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37101 {
37102 PyThreadState* __tstate = wxPyBeginAllowThreads();
37103 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37104 wxPyEndAllowThreads(__tstate);
37105 if (PyErr_Occurred()) SWIG_fail;
37106 }
37107 {
37108 #if wxUSE_UNICODE
37109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37110 #else
37111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37112 #endif
37113 }
37114 return resultobj;
37115 fail:
37116 return NULL;
37117 }
37118
37119
37120 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37121 PyObject *resultobj = 0;
37122 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37123 wxString result;
37124 void *argp1 = 0 ;
37125 int res1 = 0 ;
37126 PyObject *swig_obj[1] ;
37127
37128 if (!args) SWIG_fail;
37129 swig_obj[0] = args;
37130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37131 if (!SWIG_IsOK(res1)) {
37132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37133 }
37134 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37135 {
37136 PyThreadState* __tstate = wxPyBeginAllowThreads();
37137 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37138 wxPyEndAllowThreads(__tstate);
37139 if (PyErr_Occurred()) SWIG_fail;
37140 }
37141 {
37142 #if wxUSE_UNICODE
37143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37144 #else
37145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37146 #endif
37147 }
37148 return resultobj;
37149 fail:
37150 return NULL;
37151 }
37152
37153
37154 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(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_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37167 }
37168 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37169 {
37170 PyThreadState* __tstate = wxPyBeginAllowThreads();
37171 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
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_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37189 PyObject *resultobj = 0;
37190 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37191 wxString result;
37192 void *argp1 = 0 ;
37193 int res1 = 0 ;
37194 PyObject *swig_obj[1] ;
37195
37196 if (!args) SWIG_fail;
37197 swig_obj[0] = args;
37198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37199 if (!SWIG_IsOK(res1)) {
37200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37201 }
37202 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37203 {
37204 PyThreadState* __tstate = wxPyBeginAllowThreads();
37205 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37206 wxPyEndAllowThreads(__tstate);
37207 if (PyErr_Occurred()) SWIG_fail;
37208 }
37209 {
37210 #if wxUSE_UNICODE
37211 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37212 #else
37213 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37214 #endif
37215 }
37216 return resultobj;
37217 fail:
37218 return NULL;
37219 }
37220
37221
37222 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37223 PyObject *resultobj = 0;
37224 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37225 wxString result;
37226 void *argp1 = 0 ;
37227 int res1 = 0 ;
37228 PyObject *swig_obj[1] ;
37229
37230 if (!args) SWIG_fail;
37231 swig_obj[0] = args;
37232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37233 if (!SWIG_IsOK(res1)) {
37234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37235 }
37236 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37237 {
37238 PyThreadState* __tstate = wxPyBeginAllowThreads();
37239 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37240 wxPyEndAllowThreads(__tstate);
37241 if (PyErr_Occurred()) SWIG_fail;
37242 }
37243 {
37244 #if wxUSE_UNICODE
37245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37246 #else
37247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37248 #endif
37249 }
37250 return resultobj;
37251 fail:
37252 return NULL;
37253 }
37254
37255
37256 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37257 PyObject *resultobj = 0;
37258 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37259 wxString *arg2 = 0 ;
37260 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37261 wxString result;
37262 void *argp1 = 0 ;
37263 int res1 = 0 ;
37264 bool temp2 = false ;
37265 int val3 ;
37266 int ecode3 = 0 ;
37267 PyObject * obj0 = 0 ;
37268 PyObject * obj1 = 0 ;
37269 PyObject * obj2 = 0 ;
37270 char * kwnames[] = {
37271 (char *) "self",(char *) "lang",(char *) "category", NULL
37272 };
37273
37274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37276 if (!SWIG_IsOK(res1)) {
37277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37278 }
37279 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37280 {
37281 arg2 = wxString_in_helper(obj1);
37282 if (arg2 == NULL) SWIG_fail;
37283 temp2 = true;
37284 }
37285 if (obj2) {
37286 ecode3 = SWIG_AsVal_int(obj2, &val3);
37287 if (!SWIG_IsOK(ecode3)) {
37288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37289 }
37290 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37291 }
37292 {
37293 PyThreadState* __tstate = wxPyBeginAllowThreads();
37294 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37295 wxPyEndAllowThreads(__tstate);
37296 if (PyErr_Occurred()) SWIG_fail;
37297 }
37298 {
37299 #if wxUSE_UNICODE
37300 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37301 #else
37302 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37303 #endif
37304 }
37305 {
37306 if (temp2)
37307 delete arg2;
37308 }
37309 return resultobj;
37310 fail:
37311 {
37312 if (temp2)
37313 delete arg2;
37314 }
37315 return NULL;
37316 }
37317
37318
37319 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37320 PyObject *resultobj = 0;
37321 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37322 wxString result;
37323 void *argp1 = 0 ;
37324 int res1 = 0 ;
37325 PyObject *swig_obj[1] ;
37326
37327 if (!args) SWIG_fail;
37328 swig_obj[0] = args;
37329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37330 if (!SWIG_IsOK(res1)) {
37331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37332 }
37333 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37334 {
37335 PyThreadState* __tstate = wxPyBeginAllowThreads();
37336 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37337 wxPyEndAllowThreads(__tstate);
37338 if (PyErr_Occurred()) SWIG_fail;
37339 }
37340 {
37341 #if wxUSE_UNICODE
37342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37343 #else
37344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37345 #endif
37346 }
37347 return resultobj;
37348 fail:
37349 return NULL;
37350 }
37351
37352
37353 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37354 PyObject *resultobj = 0;
37355 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37356 wxString result;
37357 void *argp1 = 0 ;
37358 int res1 = 0 ;
37359 PyObject *swig_obj[1] ;
37360
37361 if (!args) SWIG_fail;
37362 swig_obj[0] = args;
37363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37364 if (!SWIG_IsOK(res1)) {
37365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37366 }
37367 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37368 {
37369 PyThreadState* __tstate = wxPyBeginAllowThreads();
37370 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37371 wxPyEndAllowThreads(__tstate);
37372 if (PyErr_Occurred()) SWIG_fail;
37373 }
37374 {
37375 #if wxUSE_UNICODE
37376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37377 #else
37378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37379 #endif
37380 }
37381 return resultobj;
37382 fail:
37383 return NULL;
37384 }
37385
37386
37387 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37388 PyObject *resultobj = 0;
37389 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37390 wxString *arg2 = 0 ;
37391 void *argp1 = 0 ;
37392 int res1 = 0 ;
37393 bool temp2 = false ;
37394 PyObject * obj0 = 0 ;
37395 PyObject * obj1 = 0 ;
37396 char * kwnames[] = {
37397 (char *) "self",(char *) "prefix", NULL
37398 };
37399
37400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37402 if (!SWIG_IsOK(res1)) {
37403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37404 }
37405 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37406 {
37407 arg2 = wxString_in_helper(obj1);
37408 if (arg2 == NULL) SWIG_fail;
37409 temp2 = true;
37410 }
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 resultobj = SWIG_Py_Void();
37418 {
37419 if (temp2)
37420 delete arg2;
37421 }
37422 return resultobj;
37423 fail:
37424 {
37425 if (temp2)
37426 delete arg2;
37427 }
37428 return NULL;
37429 }
37430
37431
37432 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37433 PyObject *resultobj = 0;
37434 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37435 wxString result;
37436 void *argp1 = 0 ;
37437 int res1 = 0 ;
37438 PyObject *swig_obj[1] ;
37439
37440 if (!args) SWIG_fail;
37441 swig_obj[0] = args;
37442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37443 if (!SWIG_IsOK(res1)) {
37444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37445 }
37446 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37447 {
37448 PyThreadState* __tstate = wxPyBeginAllowThreads();
37449 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37450 wxPyEndAllowThreads(__tstate);
37451 if (PyErr_Occurred()) SWIG_fail;
37452 }
37453 {
37454 #if wxUSE_UNICODE
37455 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37456 #else
37457 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37458 #endif
37459 }
37460 return resultobj;
37461 fail:
37462 return NULL;
37463 }
37464
37465
37466 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37467 PyObject *obj;
37468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37469 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37470 return SWIG_Py_Void();
37471 }
37472
37473 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37474 PyObject *resultobj = 0;
37475 wxEventType arg1 ;
37476 wxPowerEvent *result = 0 ;
37477 int val1 ;
37478 int ecode1 = 0 ;
37479 PyObject * obj0 = 0 ;
37480 char * kwnames[] = {
37481 (char *) "evtType", NULL
37482 };
37483
37484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37485 ecode1 = SWIG_AsVal_int(obj0, &val1);
37486 if (!SWIG_IsOK(ecode1)) {
37487 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37488 }
37489 arg1 = static_cast< wxEventType >(val1);
37490 {
37491 PyThreadState* __tstate = wxPyBeginAllowThreads();
37492 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37493 wxPyEndAllowThreads(__tstate);
37494 if (PyErr_Occurred()) SWIG_fail;
37495 }
37496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37497 return resultobj;
37498 fail:
37499 return NULL;
37500 }
37501
37502
37503 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37504 PyObject *resultobj = 0;
37505 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37506 void *argp1 = 0 ;
37507 int res1 = 0 ;
37508 PyObject *swig_obj[1] ;
37509
37510 if (!args) SWIG_fail;
37511 swig_obj[0] = args;
37512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37513 if (!SWIG_IsOK(res1)) {
37514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37515 }
37516 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37517 {
37518 PyThreadState* __tstate = wxPyBeginAllowThreads();
37519 (arg1)->Veto();
37520 wxPyEndAllowThreads(__tstate);
37521 if (PyErr_Occurred()) SWIG_fail;
37522 }
37523 resultobj = SWIG_Py_Void();
37524 return resultobj;
37525 fail:
37526 return NULL;
37527 }
37528
37529
37530 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37531 PyObject *resultobj = 0;
37532 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37533 bool result;
37534 void *argp1 = 0 ;
37535 int res1 = 0 ;
37536 PyObject *swig_obj[1] ;
37537
37538 if (!args) SWIG_fail;
37539 swig_obj[0] = args;
37540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37541 if (!SWIG_IsOK(res1)) {
37542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37543 }
37544 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37545 {
37546 PyThreadState* __tstate = wxPyBeginAllowThreads();
37547 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37548 wxPyEndAllowThreads(__tstate);
37549 if (PyErr_Occurred()) SWIG_fail;
37550 }
37551 {
37552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37553 }
37554 return resultobj;
37555 fail:
37556 return NULL;
37557 }
37558
37559
37560 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37561 PyObject *obj;
37562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37563 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37564 return SWIG_Py_Void();
37565 }
37566
37567 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37568 return SWIG_Python_InitShadowInstance(args);
37569 }
37570
37571 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37572 PyObject *resultobj = 0;
37573 wxPowerType result;
37574
37575 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37576 {
37577 PyThreadState* __tstate = wxPyBeginAllowThreads();
37578 result = (wxPowerType)wxGetPowerType();
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 resultobj = SWIG_From_int(static_cast< int >(result));
37583 return resultobj;
37584 fail:
37585 return NULL;
37586 }
37587
37588
37589 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37590 PyObject *resultobj = 0;
37591 wxBatteryState result;
37592
37593 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37594 {
37595 PyThreadState* __tstate = wxPyBeginAllowThreads();
37596 result = (wxBatteryState)wxGetBatteryState();
37597 wxPyEndAllowThreads(__tstate);
37598 if (PyErr_Occurred()) SWIG_fail;
37599 }
37600 resultobj = SWIG_From_int(static_cast< int >(result));
37601 return resultobj;
37602 fail:
37603 return NULL;
37604 }
37605
37606
37607 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37608 PyObject *resultobj = 0;
37609 wxAboutDialogInfo *result = 0 ;
37610
37611 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37612 {
37613 PyThreadState* __tstate = wxPyBeginAllowThreads();
37614 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37615 wxPyEndAllowThreads(__tstate);
37616 if (PyErr_Occurred()) SWIG_fail;
37617 }
37618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37619 return resultobj;
37620 fail:
37621 return NULL;
37622 }
37623
37624
37625 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37626 PyObject *resultobj = 0;
37627 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37628 void *argp1 = 0 ;
37629 int res1 = 0 ;
37630 PyObject *swig_obj[1] ;
37631
37632 if (!args) SWIG_fail;
37633 swig_obj[0] = args;
37634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37635 if (!SWIG_IsOK(res1)) {
37636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37637 }
37638 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37639 {
37640 PyThreadState* __tstate = wxPyBeginAllowThreads();
37641 delete arg1;
37642
37643 wxPyEndAllowThreads(__tstate);
37644 if (PyErr_Occurred()) SWIG_fail;
37645 }
37646 resultobj = SWIG_Py_Void();
37647 return resultobj;
37648 fail:
37649 return NULL;
37650 }
37651
37652
37653 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37654 PyObject *resultobj = 0;
37655 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37656 wxString *arg2 = 0 ;
37657 void *argp1 = 0 ;
37658 int res1 = 0 ;
37659 bool temp2 = false ;
37660 PyObject * obj0 = 0 ;
37661 PyObject * obj1 = 0 ;
37662 char * kwnames[] = {
37663 (char *) "self",(char *) "name", NULL
37664 };
37665
37666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37668 if (!SWIG_IsOK(res1)) {
37669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37670 }
37671 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37672 {
37673 arg2 = wxString_in_helper(obj1);
37674 if (arg2 == NULL) SWIG_fail;
37675 temp2 = true;
37676 }
37677 {
37678 PyThreadState* __tstate = wxPyBeginAllowThreads();
37679 (arg1)->SetName((wxString const &)*arg2);
37680 wxPyEndAllowThreads(__tstate);
37681 if (PyErr_Occurred()) SWIG_fail;
37682 }
37683 resultobj = SWIG_Py_Void();
37684 {
37685 if (temp2)
37686 delete arg2;
37687 }
37688 return resultobj;
37689 fail:
37690 {
37691 if (temp2)
37692 delete arg2;
37693 }
37694 return NULL;
37695 }
37696
37697
37698 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37699 PyObject *resultobj = 0;
37700 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37701 wxString result;
37702 void *argp1 = 0 ;
37703 int res1 = 0 ;
37704 PyObject *swig_obj[1] ;
37705
37706 if (!args) SWIG_fail;
37707 swig_obj[0] = args;
37708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37709 if (!SWIG_IsOK(res1)) {
37710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37711 }
37712 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37713 {
37714 PyThreadState* __tstate = wxPyBeginAllowThreads();
37715 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37716 wxPyEndAllowThreads(__tstate);
37717 if (PyErr_Occurred()) SWIG_fail;
37718 }
37719 {
37720 #if wxUSE_UNICODE
37721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37722 #else
37723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37724 #endif
37725 }
37726 return resultobj;
37727 fail:
37728 return NULL;
37729 }
37730
37731
37732 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37733 PyObject *resultobj = 0;
37734 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37735 wxString *arg2 = 0 ;
37736 void *argp1 = 0 ;
37737 int res1 = 0 ;
37738 bool temp2 = false ;
37739 PyObject * obj0 = 0 ;
37740 PyObject * obj1 = 0 ;
37741 char * kwnames[] = {
37742 (char *) "self",(char *) "version", NULL
37743 };
37744
37745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37747 if (!SWIG_IsOK(res1)) {
37748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37749 }
37750 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37751 {
37752 arg2 = wxString_in_helper(obj1);
37753 if (arg2 == NULL) SWIG_fail;
37754 temp2 = true;
37755 }
37756 {
37757 PyThreadState* __tstate = wxPyBeginAllowThreads();
37758 (arg1)->SetVersion((wxString const &)*arg2);
37759 wxPyEndAllowThreads(__tstate);
37760 if (PyErr_Occurred()) SWIG_fail;
37761 }
37762 resultobj = SWIG_Py_Void();
37763 {
37764 if (temp2)
37765 delete arg2;
37766 }
37767 return resultobj;
37768 fail:
37769 {
37770 if (temp2)
37771 delete arg2;
37772 }
37773 return NULL;
37774 }
37775
37776
37777 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37778 PyObject *resultobj = 0;
37779 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37780 bool result;
37781 void *argp1 = 0 ;
37782 int res1 = 0 ;
37783 PyObject *swig_obj[1] ;
37784
37785 if (!args) SWIG_fail;
37786 swig_obj[0] = args;
37787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37788 if (!SWIG_IsOK(res1)) {
37789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37790 }
37791 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37792 {
37793 PyThreadState* __tstate = wxPyBeginAllowThreads();
37794 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37795 wxPyEndAllowThreads(__tstate);
37796 if (PyErr_Occurred()) SWIG_fail;
37797 }
37798 {
37799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37800 }
37801 return resultobj;
37802 fail:
37803 return NULL;
37804 }
37805
37806
37807 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37808 PyObject *resultobj = 0;
37809 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37810 wxString result;
37811 void *argp1 = 0 ;
37812 int res1 = 0 ;
37813 PyObject *swig_obj[1] ;
37814
37815 if (!args) SWIG_fail;
37816 swig_obj[0] = args;
37817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37818 if (!SWIG_IsOK(res1)) {
37819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37820 }
37821 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37822 {
37823 PyThreadState* __tstate = wxPyBeginAllowThreads();
37824 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37825 wxPyEndAllowThreads(__tstate);
37826 if (PyErr_Occurred()) SWIG_fail;
37827 }
37828 {
37829 #if wxUSE_UNICODE
37830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37831 #else
37832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37833 #endif
37834 }
37835 return resultobj;
37836 fail:
37837 return NULL;
37838 }
37839
37840
37841 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37842 PyObject *resultobj = 0;
37843 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37844 wxString *arg2 = 0 ;
37845 void *argp1 = 0 ;
37846 int res1 = 0 ;
37847 bool temp2 = false ;
37848 PyObject * obj0 = 0 ;
37849 PyObject * obj1 = 0 ;
37850 char * kwnames[] = {
37851 (char *) "self",(char *) "desc", NULL
37852 };
37853
37854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37856 if (!SWIG_IsOK(res1)) {
37857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37858 }
37859 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37860 {
37861 arg2 = wxString_in_helper(obj1);
37862 if (arg2 == NULL) SWIG_fail;
37863 temp2 = true;
37864 }
37865 {
37866 PyThreadState* __tstate = wxPyBeginAllowThreads();
37867 (arg1)->SetDescription((wxString const &)*arg2);
37868 wxPyEndAllowThreads(__tstate);
37869 if (PyErr_Occurred()) SWIG_fail;
37870 }
37871 resultobj = SWIG_Py_Void();
37872 {
37873 if (temp2)
37874 delete arg2;
37875 }
37876 return resultobj;
37877 fail:
37878 {
37879 if (temp2)
37880 delete arg2;
37881 }
37882 return NULL;
37883 }
37884
37885
37886 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37887 PyObject *resultobj = 0;
37888 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37889 bool result;
37890 void *argp1 = 0 ;
37891 int res1 = 0 ;
37892 PyObject *swig_obj[1] ;
37893
37894 if (!args) SWIG_fail;
37895 swig_obj[0] = args;
37896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37897 if (!SWIG_IsOK(res1)) {
37898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37899 }
37900 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37901 {
37902 PyThreadState* __tstate = wxPyBeginAllowThreads();
37903 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37904 wxPyEndAllowThreads(__tstate);
37905 if (PyErr_Occurred()) SWIG_fail;
37906 }
37907 {
37908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37909 }
37910 return resultobj;
37911 fail:
37912 return NULL;
37913 }
37914
37915
37916 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37917 PyObject *resultobj = 0;
37918 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37919 wxString result;
37920 void *argp1 = 0 ;
37921 int res1 = 0 ;
37922 PyObject *swig_obj[1] ;
37923
37924 if (!args) SWIG_fail;
37925 swig_obj[0] = args;
37926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37927 if (!SWIG_IsOK(res1)) {
37928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37929 }
37930 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37931 {
37932 PyThreadState* __tstate = wxPyBeginAllowThreads();
37933 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37934 wxPyEndAllowThreads(__tstate);
37935 if (PyErr_Occurred()) SWIG_fail;
37936 }
37937 {
37938 #if wxUSE_UNICODE
37939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37940 #else
37941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37942 #endif
37943 }
37944 return resultobj;
37945 fail:
37946 return NULL;
37947 }
37948
37949
37950 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37951 PyObject *resultobj = 0;
37952 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37953 wxString *arg2 = 0 ;
37954 void *argp1 = 0 ;
37955 int res1 = 0 ;
37956 bool temp2 = false ;
37957 PyObject * obj0 = 0 ;
37958 PyObject * obj1 = 0 ;
37959 char * kwnames[] = {
37960 (char *) "self",(char *) "copyright", NULL
37961 };
37962
37963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37965 if (!SWIG_IsOK(res1)) {
37966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37967 }
37968 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37969 {
37970 arg2 = wxString_in_helper(obj1);
37971 if (arg2 == NULL) SWIG_fail;
37972 temp2 = true;
37973 }
37974 {
37975 PyThreadState* __tstate = wxPyBeginAllowThreads();
37976 (arg1)->SetCopyright((wxString const &)*arg2);
37977 wxPyEndAllowThreads(__tstate);
37978 if (PyErr_Occurred()) SWIG_fail;
37979 }
37980 resultobj = SWIG_Py_Void();
37981 {
37982 if (temp2)
37983 delete arg2;
37984 }
37985 return resultobj;
37986 fail:
37987 {
37988 if (temp2)
37989 delete arg2;
37990 }
37991 return NULL;
37992 }
37993
37994
37995 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37996 PyObject *resultobj = 0;
37997 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37998 bool result;
37999 void *argp1 = 0 ;
38000 int res1 = 0 ;
38001 PyObject *swig_obj[1] ;
38002
38003 if (!args) SWIG_fail;
38004 swig_obj[0] = args;
38005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38006 if (!SWIG_IsOK(res1)) {
38007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38008 }
38009 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38010 {
38011 PyThreadState* __tstate = wxPyBeginAllowThreads();
38012 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
38013 wxPyEndAllowThreads(__tstate);
38014 if (PyErr_Occurred()) SWIG_fail;
38015 }
38016 {
38017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38018 }
38019 return resultobj;
38020 fail:
38021 return NULL;
38022 }
38023
38024
38025 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38026 PyObject *resultobj = 0;
38027 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38028 wxString result;
38029 void *argp1 = 0 ;
38030 int res1 = 0 ;
38031 PyObject *swig_obj[1] ;
38032
38033 if (!args) SWIG_fail;
38034 swig_obj[0] = args;
38035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38036 if (!SWIG_IsOK(res1)) {
38037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38038 }
38039 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38040 {
38041 PyThreadState* __tstate = wxPyBeginAllowThreads();
38042 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
38043 wxPyEndAllowThreads(__tstate);
38044 if (PyErr_Occurred()) SWIG_fail;
38045 }
38046 {
38047 #if wxUSE_UNICODE
38048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38049 #else
38050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38051 #endif
38052 }
38053 return resultobj;
38054 fail:
38055 return NULL;
38056 }
38057
38058
38059 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38060 PyObject *resultobj = 0;
38061 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38062 wxString *arg2 = 0 ;
38063 void *argp1 = 0 ;
38064 int res1 = 0 ;
38065 bool temp2 = false ;
38066 PyObject * obj0 = 0 ;
38067 PyObject * obj1 = 0 ;
38068 char * kwnames[] = {
38069 (char *) "self",(char *) "licence", NULL
38070 };
38071
38072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
38073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38074 if (!SWIG_IsOK(res1)) {
38075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38076 }
38077 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38078 {
38079 arg2 = wxString_in_helper(obj1);
38080 if (arg2 == NULL) SWIG_fail;
38081 temp2 = true;
38082 }
38083 {
38084 PyThreadState* __tstate = wxPyBeginAllowThreads();
38085 (arg1)->SetLicence((wxString const &)*arg2);
38086 wxPyEndAllowThreads(__tstate);
38087 if (PyErr_Occurred()) SWIG_fail;
38088 }
38089 resultobj = SWIG_Py_Void();
38090 {
38091 if (temp2)
38092 delete arg2;
38093 }
38094 return resultobj;
38095 fail:
38096 {
38097 if (temp2)
38098 delete arg2;
38099 }
38100 return NULL;
38101 }
38102
38103
38104 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38105 PyObject *resultobj = 0;
38106 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38107 wxString *arg2 = 0 ;
38108 void *argp1 = 0 ;
38109 int res1 = 0 ;
38110 bool temp2 = false ;
38111 PyObject * obj0 = 0 ;
38112 PyObject * obj1 = 0 ;
38113 char * kwnames[] = {
38114 (char *) "self",(char *) "licence", NULL
38115 };
38116
38117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38119 if (!SWIG_IsOK(res1)) {
38120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38121 }
38122 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38123 {
38124 arg2 = wxString_in_helper(obj1);
38125 if (arg2 == NULL) SWIG_fail;
38126 temp2 = true;
38127 }
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 (arg1)->SetLicense((wxString const &)*arg2);
38131 wxPyEndAllowThreads(__tstate);
38132 if (PyErr_Occurred()) SWIG_fail;
38133 }
38134 resultobj = SWIG_Py_Void();
38135 {
38136 if (temp2)
38137 delete arg2;
38138 }
38139 return resultobj;
38140 fail:
38141 {
38142 if (temp2)
38143 delete arg2;
38144 }
38145 return NULL;
38146 }
38147
38148
38149 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38150 PyObject *resultobj = 0;
38151 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38152 bool result;
38153 void *argp1 = 0 ;
38154 int res1 = 0 ;
38155 PyObject *swig_obj[1] ;
38156
38157 if (!args) SWIG_fail;
38158 swig_obj[0] = args;
38159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38160 if (!SWIG_IsOK(res1)) {
38161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38162 }
38163 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38164 {
38165 PyThreadState* __tstate = wxPyBeginAllowThreads();
38166 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 {
38171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38172 }
38173 return resultobj;
38174 fail:
38175 return NULL;
38176 }
38177
38178
38179 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38180 PyObject *resultobj = 0;
38181 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38182 wxString result;
38183 void *argp1 = 0 ;
38184 int res1 = 0 ;
38185 PyObject *swig_obj[1] ;
38186
38187 if (!args) SWIG_fail;
38188 swig_obj[0] = args;
38189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38190 if (!SWIG_IsOK(res1)) {
38191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38192 }
38193 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38194 {
38195 PyThreadState* __tstate = wxPyBeginAllowThreads();
38196 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38197 wxPyEndAllowThreads(__tstate);
38198 if (PyErr_Occurred()) SWIG_fail;
38199 }
38200 {
38201 #if wxUSE_UNICODE
38202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38203 #else
38204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38205 #endif
38206 }
38207 return resultobj;
38208 fail:
38209 return NULL;
38210 }
38211
38212
38213 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38214 PyObject *resultobj = 0;
38215 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38216 wxIcon *arg2 = 0 ;
38217 void *argp1 = 0 ;
38218 int res1 = 0 ;
38219 void *argp2 = 0 ;
38220 int res2 = 0 ;
38221 PyObject * obj0 = 0 ;
38222 PyObject * obj1 = 0 ;
38223 char * kwnames[] = {
38224 (char *) "self",(char *) "icon", NULL
38225 };
38226
38227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38229 if (!SWIG_IsOK(res1)) {
38230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38231 }
38232 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38233 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38234 if (!SWIG_IsOK(res2)) {
38235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38236 }
38237 if (!argp2) {
38238 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38239 }
38240 arg2 = reinterpret_cast< wxIcon * >(argp2);
38241 {
38242 PyThreadState* __tstate = wxPyBeginAllowThreads();
38243 (arg1)->SetIcon((wxIcon const &)*arg2);
38244 wxPyEndAllowThreads(__tstate);
38245 if (PyErr_Occurred()) SWIG_fail;
38246 }
38247 resultobj = SWIG_Py_Void();
38248 return resultobj;
38249 fail:
38250 return NULL;
38251 }
38252
38253
38254 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38255 PyObject *resultobj = 0;
38256 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38257 bool result;
38258 void *argp1 = 0 ;
38259 int res1 = 0 ;
38260 PyObject *swig_obj[1] ;
38261
38262 if (!args) SWIG_fail;
38263 swig_obj[0] = args;
38264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38265 if (!SWIG_IsOK(res1)) {
38266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38267 }
38268 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38269 {
38270 PyThreadState* __tstate = wxPyBeginAllowThreads();
38271 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38272 wxPyEndAllowThreads(__tstate);
38273 if (PyErr_Occurred()) SWIG_fail;
38274 }
38275 {
38276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38277 }
38278 return resultobj;
38279 fail:
38280 return NULL;
38281 }
38282
38283
38284 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38285 PyObject *resultobj = 0;
38286 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38287 wxIcon result;
38288 void *argp1 = 0 ;
38289 int res1 = 0 ;
38290 PyObject *swig_obj[1] ;
38291
38292 if (!args) SWIG_fail;
38293 swig_obj[0] = args;
38294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38295 if (!SWIG_IsOK(res1)) {
38296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38297 }
38298 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38299 {
38300 PyThreadState* __tstate = wxPyBeginAllowThreads();
38301 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38302 wxPyEndAllowThreads(__tstate);
38303 if (PyErr_Occurred()) SWIG_fail;
38304 }
38305 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38306 return resultobj;
38307 fail:
38308 return NULL;
38309 }
38310
38311
38312 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38313 PyObject *resultobj = 0;
38314 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38315 wxString *arg2 = 0 ;
38316 wxString const &arg3_defvalue = wxEmptyString ;
38317 wxString *arg3 = (wxString *) &arg3_defvalue ;
38318 void *argp1 = 0 ;
38319 int res1 = 0 ;
38320 bool temp2 = false ;
38321 bool temp3 = false ;
38322 PyObject * obj0 = 0 ;
38323 PyObject * obj1 = 0 ;
38324 PyObject * obj2 = 0 ;
38325 char * kwnames[] = {
38326 (char *) "self",(char *) "url",(char *) "desc", NULL
38327 };
38328
38329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38331 if (!SWIG_IsOK(res1)) {
38332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38333 }
38334 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38335 {
38336 arg2 = wxString_in_helper(obj1);
38337 if (arg2 == NULL) SWIG_fail;
38338 temp2 = true;
38339 }
38340 if (obj2) {
38341 {
38342 arg3 = wxString_in_helper(obj2);
38343 if (arg3 == NULL) SWIG_fail;
38344 temp3 = true;
38345 }
38346 }
38347 {
38348 PyThreadState* __tstate = wxPyBeginAllowThreads();
38349 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38350 wxPyEndAllowThreads(__tstate);
38351 if (PyErr_Occurred()) SWIG_fail;
38352 }
38353 resultobj = SWIG_Py_Void();
38354 {
38355 if (temp2)
38356 delete arg2;
38357 }
38358 {
38359 if (temp3)
38360 delete arg3;
38361 }
38362 return resultobj;
38363 fail:
38364 {
38365 if (temp2)
38366 delete arg2;
38367 }
38368 {
38369 if (temp3)
38370 delete arg3;
38371 }
38372 return NULL;
38373 }
38374
38375
38376 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38377 PyObject *resultobj = 0;
38378 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38379 wxString result;
38380 void *argp1 = 0 ;
38381 int res1 = 0 ;
38382 PyObject *swig_obj[1] ;
38383
38384 if (!args) SWIG_fail;
38385 swig_obj[0] = args;
38386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38387 if (!SWIG_IsOK(res1)) {
38388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38389 }
38390 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38391 {
38392 PyThreadState* __tstate = wxPyBeginAllowThreads();
38393 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38394 wxPyEndAllowThreads(__tstate);
38395 if (PyErr_Occurred()) SWIG_fail;
38396 }
38397 {
38398 #if wxUSE_UNICODE
38399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38400 #else
38401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38402 #endif
38403 }
38404 return resultobj;
38405 fail:
38406 return NULL;
38407 }
38408
38409
38410 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38411 PyObject *resultobj = 0;
38412 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38413 wxString result;
38414 void *argp1 = 0 ;
38415 int res1 = 0 ;
38416 PyObject *swig_obj[1] ;
38417
38418 if (!args) SWIG_fail;
38419 swig_obj[0] = args;
38420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38421 if (!SWIG_IsOK(res1)) {
38422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38423 }
38424 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38425 {
38426 PyThreadState* __tstate = wxPyBeginAllowThreads();
38427 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38428 wxPyEndAllowThreads(__tstate);
38429 if (PyErr_Occurred()) SWIG_fail;
38430 }
38431 {
38432 #if wxUSE_UNICODE
38433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38434 #else
38435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38436 #endif
38437 }
38438 return resultobj;
38439 fail:
38440 return NULL;
38441 }
38442
38443
38444 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38445 PyObject *resultobj = 0;
38446 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38447 bool result;
38448 void *argp1 = 0 ;
38449 int res1 = 0 ;
38450 PyObject *swig_obj[1] ;
38451
38452 if (!args) SWIG_fail;
38453 swig_obj[0] = args;
38454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38455 if (!SWIG_IsOK(res1)) {
38456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38457 }
38458 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38459 {
38460 PyThreadState* __tstate = wxPyBeginAllowThreads();
38461 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38462 wxPyEndAllowThreads(__tstate);
38463 if (PyErr_Occurred()) SWIG_fail;
38464 }
38465 {
38466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38467 }
38468 return resultobj;
38469 fail:
38470 return NULL;
38471 }
38472
38473
38474 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38475 PyObject *resultobj = 0;
38476 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38477 wxArrayString *arg2 = 0 ;
38478 void *argp1 = 0 ;
38479 int res1 = 0 ;
38480 bool temp2 = false ;
38481 PyObject * obj0 = 0 ;
38482 PyObject * obj1 = 0 ;
38483 char * kwnames[] = {
38484 (char *) "self",(char *) "developers", NULL
38485 };
38486
38487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38489 if (!SWIG_IsOK(res1)) {
38490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38491 }
38492 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38493 {
38494 if (! PySequence_Check(obj1)) {
38495 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38496 SWIG_fail;
38497 }
38498 arg2 = new wxArrayString;
38499 temp2 = true;
38500 int i, len=PySequence_Length(obj1);
38501 for (i=0; i<len; i++) {
38502 PyObject* item = PySequence_GetItem(obj1, i);
38503 wxString* s = wxString_in_helper(item);
38504 if (PyErr_Occurred()) SWIG_fail;
38505 arg2->Add(*s);
38506 delete s;
38507 Py_DECREF(item);
38508 }
38509 }
38510 {
38511 PyThreadState* __tstate = wxPyBeginAllowThreads();
38512 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38513 wxPyEndAllowThreads(__tstate);
38514 if (PyErr_Occurred()) SWIG_fail;
38515 }
38516 resultobj = SWIG_Py_Void();
38517 {
38518 if (temp2) delete arg2;
38519 }
38520 return resultobj;
38521 fail:
38522 {
38523 if (temp2) delete arg2;
38524 }
38525 return NULL;
38526 }
38527
38528
38529 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38530 PyObject *resultobj = 0;
38531 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38532 wxString *arg2 = 0 ;
38533 void *argp1 = 0 ;
38534 int res1 = 0 ;
38535 bool temp2 = false ;
38536 PyObject * obj0 = 0 ;
38537 PyObject * obj1 = 0 ;
38538 char * kwnames[] = {
38539 (char *) "self",(char *) "developer", NULL
38540 };
38541
38542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38544 if (!SWIG_IsOK(res1)) {
38545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38546 }
38547 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38548 {
38549 arg2 = wxString_in_helper(obj1);
38550 if (arg2 == NULL) SWIG_fail;
38551 temp2 = true;
38552 }
38553 {
38554 PyThreadState* __tstate = wxPyBeginAllowThreads();
38555 (arg1)->AddDeveloper((wxString const &)*arg2);
38556 wxPyEndAllowThreads(__tstate);
38557 if (PyErr_Occurred()) SWIG_fail;
38558 }
38559 resultobj = SWIG_Py_Void();
38560 {
38561 if (temp2)
38562 delete arg2;
38563 }
38564 return resultobj;
38565 fail:
38566 {
38567 if (temp2)
38568 delete arg2;
38569 }
38570 return NULL;
38571 }
38572
38573
38574 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38575 PyObject *resultobj = 0;
38576 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38577 bool result;
38578 void *argp1 = 0 ;
38579 int res1 = 0 ;
38580 PyObject *swig_obj[1] ;
38581
38582 if (!args) SWIG_fail;
38583 swig_obj[0] = args;
38584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38585 if (!SWIG_IsOK(res1)) {
38586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38587 }
38588 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38589 {
38590 PyThreadState* __tstate = wxPyBeginAllowThreads();
38591 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38592 wxPyEndAllowThreads(__tstate);
38593 if (PyErr_Occurred()) SWIG_fail;
38594 }
38595 {
38596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38597 }
38598 return resultobj;
38599 fail:
38600 return NULL;
38601 }
38602
38603
38604 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38605 PyObject *resultobj = 0;
38606 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38607 wxArrayString *result = 0 ;
38608 void *argp1 = 0 ;
38609 int res1 = 0 ;
38610 PyObject *swig_obj[1] ;
38611
38612 if (!args) SWIG_fail;
38613 swig_obj[0] = args;
38614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38615 if (!SWIG_IsOK(res1)) {
38616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38617 }
38618 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38619 {
38620 PyThreadState* __tstate = wxPyBeginAllowThreads();
38621 {
38622 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38623 result = (wxArrayString *) &_result_ref;
38624 }
38625 wxPyEndAllowThreads(__tstate);
38626 if (PyErr_Occurred()) SWIG_fail;
38627 }
38628 {
38629 resultobj = wxArrayString2PyList_helper(*result);
38630 }
38631 return resultobj;
38632 fail:
38633 return NULL;
38634 }
38635
38636
38637 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38638 PyObject *resultobj = 0;
38639 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38640 wxArrayString *arg2 = 0 ;
38641 void *argp1 = 0 ;
38642 int res1 = 0 ;
38643 bool temp2 = false ;
38644 PyObject * obj0 = 0 ;
38645 PyObject * obj1 = 0 ;
38646 char * kwnames[] = {
38647 (char *) "self",(char *) "docwriters", NULL
38648 };
38649
38650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38652 if (!SWIG_IsOK(res1)) {
38653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38654 }
38655 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38656 {
38657 if (! PySequence_Check(obj1)) {
38658 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38659 SWIG_fail;
38660 }
38661 arg2 = new wxArrayString;
38662 temp2 = true;
38663 int i, len=PySequence_Length(obj1);
38664 for (i=0; i<len; i++) {
38665 PyObject* item = PySequence_GetItem(obj1, i);
38666 wxString* s = wxString_in_helper(item);
38667 if (PyErr_Occurred()) SWIG_fail;
38668 arg2->Add(*s);
38669 delete s;
38670 Py_DECREF(item);
38671 }
38672 }
38673 {
38674 PyThreadState* __tstate = wxPyBeginAllowThreads();
38675 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38676 wxPyEndAllowThreads(__tstate);
38677 if (PyErr_Occurred()) SWIG_fail;
38678 }
38679 resultobj = SWIG_Py_Void();
38680 {
38681 if (temp2) delete arg2;
38682 }
38683 return resultobj;
38684 fail:
38685 {
38686 if (temp2) delete arg2;
38687 }
38688 return NULL;
38689 }
38690
38691
38692 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38693 PyObject *resultobj = 0;
38694 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38695 wxString *arg2 = 0 ;
38696 void *argp1 = 0 ;
38697 int res1 = 0 ;
38698 bool temp2 = false ;
38699 PyObject * obj0 = 0 ;
38700 PyObject * obj1 = 0 ;
38701 char * kwnames[] = {
38702 (char *) "self",(char *) "docwriter", NULL
38703 };
38704
38705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38707 if (!SWIG_IsOK(res1)) {
38708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38709 }
38710 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38711 {
38712 arg2 = wxString_in_helper(obj1);
38713 if (arg2 == NULL) SWIG_fail;
38714 temp2 = true;
38715 }
38716 {
38717 PyThreadState* __tstate = wxPyBeginAllowThreads();
38718 (arg1)->AddDocWriter((wxString const &)*arg2);
38719 wxPyEndAllowThreads(__tstate);
38720 if (PyErr_Occurred()) SWIG_fail;
38721 }
38722 resultobj = SWIG_Py_Void();
38723 {
38724 if (temp2)
38725 delete arg2;
38726 }
38727 return resultobj;
38728 fail:
38729 {
38730 if (temp2)
38731 delete arg2;
38732 }
38733 return NULL;
38734 }
38735
38736
38737 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38738 PyObject *resultobj = 0;
38739 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38740 bool result;
38741 void *argp1 = 0 ;
38742 int res1 = 0 ;
38743 PyObject *swig_obj[1] ;
38744
38745 if (!args) SWIG_fail;
38746 swig_obj[0] = args;
38747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38748 if (!SWIG_IsOK(res1)) {
38749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38750 }
38751 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38752 {
38753 PyThreadState* __tstate = wxPyBeginAllowThreads();
38754 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38755 wxPyEndAllowThreads(__tstate);
38756 if (PyErr_Occurred()) SWIG_fail;
38757 }
38758 {
38759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38760 }
38761 return resultobj;
38762 fail:
38763 return NULL;
38764 }
38765
38766
38767 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38768 PyObject *resultobj = 0;
38769 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38770 wxArrayString *result = 0 ;
38771 void *argp1 = 0 ;
38772 int res1 = 0 ;
38773 PyObject *swig_obj[1] ;
38774
38775 if (!args) SWIG_fail;
38776 swig_obj[0] = args;
38777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38778 if (!SWIG_IsOK(res1)) {
38779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38780 }
38781 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38782 {
38783 PyThreadState* __tstate = wxPyBeginAllowThreads();
38784 {
38785 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38786 result = (wxArrayString *) &_result_ref;
38787 }
38788 wxPyEndAllowThreads(__tstate);
38789 if (PyErr_Occurred()) SWIG_fail;
38790 }
38791 {
38792 resultobj = wxArrayString2PyList_helper(*result);
38793 }
38794 return resultobj;
38795 fail:
38796 return NULL;
38797 }
38798
38799
38800 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38801 PyObject *resultobj = 0;
38802 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38803 wxArrayString *arg2 = 0 ;
38804 void *argp1 = 0 ;
38805 int res1 = 0 ;
38806 bool temp2 = false ;
38807 PyObject * obj0 = 0 ;
38808 PyObject * obj1 = 0 ;
38809 char * kwnames[] = {
38810 (char *) "self",(char *) "artists", NULL
38811 };
38812
38813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38815 if (!SWIG_IsOK(res1)) {
38816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38817 }
38818 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38819 {
38820 if (! PySequence_Check(obj1)) {
38821 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38822 SWIG_fail;
38823 }
38824 arg2 = new wxArrayString;
38825 temp2 = true;
38826 int i, len=PySequence_Length(obj1);
38827 for (i=0; i<len; i++) {
38828 PyObject* item = PySequence_GetItem(obj1, i);
38829 wxString* s = wxString_in_helper(item);
38830 if (PyErr_Occurred()) SWIG_fail;
38831 arg2->Add(*s);
38832 delete s;
38833 Py_DECREF(item);
38834 }
38835 }
38836 {
38837 PyThreadState* __tstate = wxPyBeginAllowThreads();
38838 (arg1)->SetArtists((wxArrayString const &)*arg2);
38839 wxPyEndAllowThreads(__tstate);
38840 if (PyErr_Occurred()) SWIG_fail;
38841 }
38842 resultobj = SWIG_Py_Void();
38843 {
38844 if (temp2) delete arg2;
38845 }
38846 return resultobj;
38847 fail:
38848 {
38849 if (temp2) delete arg2;
38850 }
38851 return NULL;
38852 }
38853
38854
38855 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38856 PyObject *resultobj = 0;
38857 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38858 wxString *arg2 = 0 ;
38859 void *argp1 = 0 ;
38860 int res1 = 0 ;
38861 bool temp2 = false ;
38862 PyObject * obj0 = 0 ;
38863 PyObject * obj1 = 0 ;
38864 char * kwnames[] = {
38865 (char *) "self",(char *) "artist", NULL
38866 };
38867
38868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38870 if (!SWIG_IsOK(res1)) {
38871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38872 }
38873 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38874 {
38875 arg2 = wxString_in_helper(obj1);
38876 if (arg2 == NULL) SWIG_fail;
38877 temp2 = true;
38878 }
38879 {
38880 PyThreadState* __tstate = wxPyBeginAllowThreads();
38881 (arg1)->AddArtist((wxString const &)*arg2);
38882 wxPyEndAllowThreads(__tstate);
38883 if (PyErr_Occurred()) SWIG_fail;
38884 }
38885 resultobj = SWIG_Py_Void();
38886 {
38887 if (temp2)
38888 delete arg2;
38889 }
38890 return resultobj;
38891 fail:
38892 {
38893 if (temp2)
38894 delete arg2;
38895 }
38896 return NULL;
38897 }
38898
38899
38900 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38901 PyObject *resultobj = 0;
38902 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38903 bool result;
38904 void *argp1 = 0 ;
38905 int res1 = 0 ;
38906 PyObject *swig_obj[1] ;
38907
38908 if (!args) SWIG_fail;
38909 swig_obj[0] = args;
38910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38911 if (!SWIG_IsOK(res1)) {
38912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38913 }
38914 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38915 {
38916 PyThreadState* __tstate = wxPyBeginAllowThreads();
38917 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38918 wxPyEndAllowThreads(__tstate);
38919 if (PyErr_Occurred()) SWIG_fail;
38920 }
38921 {
38922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38923 }
38924 return resultobj;
38925 fail:
38926 return NULL;
38927 }
38928
38929
38930 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38931 PyObject *resultobj = 0;
38932 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38933 wxArrayString *result = 0 ;
38934 void *argp1 = 0 ;
38935 int res1 = 0 ;
38936 PyObject *swig_obj[1] ;
38937
38938 if (!args) SWIG_fail;
38939 swig_obj[0] = args;
38940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38941 if (!SWIG_IsOK(res1)) {
38942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38943 }
38944 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38945 {
38946 PyThreadState* __tstate = wxPyBeginAllowThreads();
38947 {
38948 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38949 result = (wxArrayString *) &_result_ref;
38950 }
38951 wxPyEndAllowThreads(__tstate);
38952 if (PyErr_Occurred()) SWIG_fail;
38953 }
38954 {
38955 resultobj = wxArrayString2PyList_helper(*result);
38956 }
38957 return resultobj;
38958 fail:
38959 return NULL;
38960 }
38961
38962
38963 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38964 PyObject *resultobj = 0;
38965 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38966 wxArrayString *arg2 = 0 ;
38967 void *argp1 = 0 ;
38968 int res1 = 0 ;
38969 bool temp2 = false ;
38970 PyObject * obj0 = 0 ;
38971 PyObject * obj1 = 0 ;
38972 char * kwnames[] = {
38973 (char *) "self",(char *) "translators", NULL
38974 };
38975
38976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38978 if (!SWIG_IsOK(res1)) {
38979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38980 }
38981 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38982 {
38983 if (! PySequence_Check(obj1)) {
38984 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38985 SWIG_fail;
38986 }
38987 arg2 = new wxArrayString;
38988 temp2 = true;
38989 int i, len=PySequence_Length(obj1);
38990 for (i=0; i<len; i++) {
38991 PyObject* item = PySequence_GetItem(obj1, i);
38992 wxString* s = wxString_in_helper(item);
38993 if (PyErr_Occurred()) SWIG_fail;
38994 arg2->Add(*s);
38995 delete s;
38996 Py_DECREF(item);
38997 }
38998 }
38999 {
39000 PyThreadState* __tstate = wxPyBeginAllowThreads();
39001 (arg1)->SetTranslators((wxArrayString const &)*arg2);
39002 wxPyEndAllowThreads(__tstate);
39003 if (PyErr_Occurred()) SWIG_fail;
39004 }
39005 resultobj = SWIG_Py_Void();
39006 {
39007 if (temp2) delete arg2;
39008 }
39009 return resultobj;
39010 fail:
39011 {
39012 if (temp2) delete arg2;
39013 }
39014 return NULL;
39015 }
39016
39017
39018 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39019 PyObject *resultobj = 0;
39020 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39021 wxString *arg2 = 0 ;
39022 void *argp1 = 0 ;
39023 int res1 = 0 ;
39024 bool temp2 = false ;
39025 PyObject * obj0 = 0 ;
39026 PyObject * obj1 = 0 ;
39027 char * kwnames[] = {
39028 (char *) "self",(char *) "translator", NULL
39029 };
39030
39031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
39032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39033 if (!SWIG_IsOK(res1)) {
39034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
39035 }
39036 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39037 {
39038 arg2 = wxString_in_helper(obj1);
39039 if (arg2 == NULL) SWIG_fail;
39040 temp2 = true;
39041 }
39042 {
39043 PyThreadState* __tstate = wxPyBeginAllowThreads();
39044 (arg1)->AddTranslator((wxString const &)*arg2);
39045 wxPyEndAllowThreads(__tstate);
39046 if (PyErr_Occurred()) SWIG_fail;
39047 }
39048 resultobj = SWIG_Py_Void();
39049 {
39050 if (temp2)
39051 delete arg2;
39052 }
39053 return resultobj;
39054 fail:
39055 {
39056 if (temp2)
39057 delete arg2;
39058 }
39059 return NULL;
39060 }
39061
39062
39063 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39064 PyObject *resultobj = 0;
39065 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39066 bool result;
39067 void *argp1 = 0 ;
39068 int res1 = 0 ;
39069 PyObject *swig_obj[1] ;
39070
39071 if (!args) SWIG_fail;
39072 swig_obj[0] = args;
39073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39074 if (!SWIG_IsOK(res1)) {
39075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39076 }
39077 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39078 {
39079 PyThreadState* __tstate = wxPyBeginAllowThreads();
39080 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
39081 wxPyEndAllowThreads(__tstate);
39082 if (PyErr_Occurred()) SWIG_fail;
39083 }
39084 {
39085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39086 }
39087 return resultobj;
39088 fail:
39089 return NULL;
39090 }
39091
39092
39093 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39094 PyObject *resultobj = 0;
39095 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39096 wxArrayString *result = 0 ;
39097 void *argp1 = 0 ;
39098 int res1 = 0 ;
39099 PyObject *swig_obj[1] ;
39100
39101 if (!args) SWIG_fail;
39102 swig_obj[0] = args;
39103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39104 if (!SWIG_IsOK(res1)) {
39105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39106 }
39107 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39108 {
39109 PyThreadState* __tstate = wxPyBeginAllowThreads();
39110 {
39111 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39112 result = (wxArrayString *) &_result_ref;
39113 }
39114 wxPyEndAllowThreads(__tstate);
39115 if (PyErr_Occurred()) SWIG_fail;
39116 }
39117 {
39118 resultobj = wxArrayString2PyList_helper(*result);
39119 }
39120 return resultobj;
39121 fail:
39122 return NULL;
39123 }
39124
39125
39126 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39127 PyObject *resultobj = 0;
39128 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39129 bool result;
39130 void *argp1 = 0 ;
39131 int res1 = 0 ;
39132 PyObject *swig_obj[1] ;
39133
39134 if (!args) SWIG_fail;
39135 swig_obj[0] = args;
39136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39137 if (!SWIG_IsOK(res1)) {
39138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39139 }
39140 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39141 {
39142 PyThreadState* __tstate = wxPyBeginAllowThreads();
39143 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39144 wxPyEndAllowThreads(__tstate);
39145 if (PyErr_Occurred()) SWIG_fail;
39146 }
39147 {
39148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39149 }
39150 return resultobj;
39151 fail:
39152 return NULL;
39153 }
39154
39155
39156 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39157 PyObject *resultobj = 0;
39158 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39159 wxString result;
39160 void *argp1 = 0 ;
39161 int res1 = 0 ;
39162 PyObject *swig_obj[1] ;
39163
39164 if (!args) SWIG_fail;
39165 swig_obj[0] = args;
39166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39167 if (!SWIG_IsOK(res1)) {
39168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39169 }
39170 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39171 {
39172 PyThreadState* __tstate = wxPyBeginAllowThreads();
39173 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39174 wxPyEndAllowThreads(__tstate);
39175 if (PyErr_Occurred()) SWIG_fail;
39176 }
39177 {
39178 #if wxUSE_UNICODE
39179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39180 #else
39181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39182 #endif
39183 }
39184 return resultobj;
39185 fail:
39186 return NULL;
39187 }
39188
39189
39190 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39191 PyObject *obj;
39192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39193 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39194 return SWIG_Py_Void();
39195 }
39196
39197 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39198 return SWIG_Python_InitShadowInstance(args);
39199 }
39200
39201 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39202 PyObject *resultobj = 0;
39203 wxAboutDialogInfo *arg1 = 0 ;
39204 void *argp1 = 0 ;
39205 int res1 = 0 ;
39206 PyObject * obj0 = 0 ;
39207 char * kwnames[] = {
39208 (char *) "info", NULL
39209 };
39210
39211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39212 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39213 if (!SWIG_IsOK(res1)) {
39214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39215 }
39216 if (!argp1) {
39217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39218 }
39219 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39220 {
39221 PyThreadState* __tstate = wxPyBeginAllowThreads();
39222 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39223 wxPyEndAllowThreads(__tstate);
39224 if (PyErr_Occurred()) SWIG_fail;
39225 }
39226 resultobj = SWIG_Py_Void();
39227 return resultobj;
39228 fail:
39229 return NULL;
39230 }
39231
39232
39233 static PyMethodDef SwigMethods[] = {
39234 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39235 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39236 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39237 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39238 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39239 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39240 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39241 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39242 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39243 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39244 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39245 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39246 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39249 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39250 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39251 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39252 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39253 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39254 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39255 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39256 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39257 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39258 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39259 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39260 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39261 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39263 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39264 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39265 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39266 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39267 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39268 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39270 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39271 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39272 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39273 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39274 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39275 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39276 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39277 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39278 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39279 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39280 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39281 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39282 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39283 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39284 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39285 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39287 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39288 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39290 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39291 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39292 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39293 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39294 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39295 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39296 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39297 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39298 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39299 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39300 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39301 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39302 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39303 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39304 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39305 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39306 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39307 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39308 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39309 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39310 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39311 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39312 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39313 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39314 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39315 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39316 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39317 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39318 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39319 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39320 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39321 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39322 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39323 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39324 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39325 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39326 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39327 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39328 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39329 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39330 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39331 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39332 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39333 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39334 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39335 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39336 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39337 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39338 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39339 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39340 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39341 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39342 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39343 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39344 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39345 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39346 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39347 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39348 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39349 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39350 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39351 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39352 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39353 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39354 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39355 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39356 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39357 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39358 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39359 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39360 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39361 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39362 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39363 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39365 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39366 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39367 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39368 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39369 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39370 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39371 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39372 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39373 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39374 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39375 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39376 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39377 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39378 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39379 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39380 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39381 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39383 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39384 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39385 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39386 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39387 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39388 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39389 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39390 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39391 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39392 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39393 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39394 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39395 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39396 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39397 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39398 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39399 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39400 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39401 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39402 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39403 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39406 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39407 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39408 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39410 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39411 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39412 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39413 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39414 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39415 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39416 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39417 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39418 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39419 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39420 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39421 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39422 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39423 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39424 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39425 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39426 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39427 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39428 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39429 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39430 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39431 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39432 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39433 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39434 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39435 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39436 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39437 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39438 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39439 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39440 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39441 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39442 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39443 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39444 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39445 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39446 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39447 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39448 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39449 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39450 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39451 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39452 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39453 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39454 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39455 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39456 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39457 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39458 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39459 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39460 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39461 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39462 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39463 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39464 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39465 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39466 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39467 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39468 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39469 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39470 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39471 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39472 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39473 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39474 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39475 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39476 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39477 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39478 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39479 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39480 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39481 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39482 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39483 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39484 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39485 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39486 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39487 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39488 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39489 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39490 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39491 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39492 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39493 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39494 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39495 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39496 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39497 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39498 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39499 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39500 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39501 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39502 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39503 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39504 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39505 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39506 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39507 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39508 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39509 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39510 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39511 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39512 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39513 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39514 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39515 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39516 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39517 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39518 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39519 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39520 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39521 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39522 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39523 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39524 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39525 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39526 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39527 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39528 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39529 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39530 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39531 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39532 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39533 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39534 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39535 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39536 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39537 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39538 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39539 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39540 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39541 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39542 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39543 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39544 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39545 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39546 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39547 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39548 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39549 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39550 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39551 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39552 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39553 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39554 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39555 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39556 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39557 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39558 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39559 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39560 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39561 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39562 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39563 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39564 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39565 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39566 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39567 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39568 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39570 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39571 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39572 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39573 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39574 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39575 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39576 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39577 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39578 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39579 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39580 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39581 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39582 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39583 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39584 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39585 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39586 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39587 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39588 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39589 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39590 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39591 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39592 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39593 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39594 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39595 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39596 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39597 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39598 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39599 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39600 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39601 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39602 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39603 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39605 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39606 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39607 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39608 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39609 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39610 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39611 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39612 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39613 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39614 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39615 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39616 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39617 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39618 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39619 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39620 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39621 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39622 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39623 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39624 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39625 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39626 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39627 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39628 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39629 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39630 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39631 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39632 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39633 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39634 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39636 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39637 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39638 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39639 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39640 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39641 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39642 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39643 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39644 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39645 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39646 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39648 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39650 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39651 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39652 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39656 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39657 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39660 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39663 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39666 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39667 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39668 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39671 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39672 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39675 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39676 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39677 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39678 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39679 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39680 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39681 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39682 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39683 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39684 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39685 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39687 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39688 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39689 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39690 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39691 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39692 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39693 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39699 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39701 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39702 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39704 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39706 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39707 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39711 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39715 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39716 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39717 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39718 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39719 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39721 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39722 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39723 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"ArtProvider_GetIconBundle", (PyCFunction) _wrap_ArtProvider_GetIconBundle, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39729 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39730 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39731 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39732 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39735 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39736 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39738 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39739 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39741 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39762 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39764 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39765 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39766 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39768 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39769 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39773 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39774 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39775 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39776 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39777 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39778 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39780 { (char *)"FileConfig_GetGlobalFileName", (PyCFunction) _wrap_FileConfig_GetGlobalFileName, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"FileConfig_GetLocalFileName", (PyCFunction) _wrap_FileConfig_GetLocalFileName, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39783 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39784 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39786 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39787 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39788 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39789 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39792 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39803 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39804 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39807 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39808 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39809 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39810 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39816 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39817 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39819 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39821 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39822 { (char *)"DateTime_GetDateOnly", (PyCFunction)_wrap_DateTime_GetDateOnly, METH_O, NULL},
39823 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39832 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39834 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39836 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39845 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39846 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39847 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39848 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39849 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39852 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39856 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39861 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39862 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39863 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39864 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39865 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39866 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39867 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39876 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39878 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39880 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39887 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39888 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39889 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39890 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39891 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39892 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39893 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39894 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39895 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39896 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39904 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39905 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39906 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39907 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39908 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39909 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39911 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39912 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39913 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39914 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39915 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39916 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39917 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39919 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39920 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39921 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39923 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39926 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39927 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39928 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39929 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39931 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39932 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39935 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39937 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39941 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39942 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39943 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39944 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39945 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39946 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39948 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39949 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39950 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39951 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39952 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39953 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39954 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39955 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39956 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39957 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39959 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39960 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39961 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39963 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39964 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39965 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39966 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39967 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39970 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39971 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39972 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39973 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39974 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39975 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39976 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39977 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39978 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39979 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39980 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39981 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39983 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39984 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39987 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39988 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39990 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39991 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39992 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39993 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39994 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39995 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39996 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39998 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39999 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
40000 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
40001 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
40003 { (char *)"DataFormat__GetId", (PyCFunction)_wrap_DataFormat__GetId, METH_O, NULL},
40004 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
40005 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
40006 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
40007 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
40008 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40009 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
40010 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40011 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
40012 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
40013 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
40014 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40015 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
40016 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
40017 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
40018 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
40019 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
40020 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
40021 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
40023 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
40024 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
40025 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
40027 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
40028 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
40029 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
40030 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
40031 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
40032 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
40033 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40034 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
40035 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
40036 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
40037 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
40038 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
40039 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40040 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
40042 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
40043 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40044 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
40045 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
40046 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
40047 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
40048 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40049 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40050 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
40051 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
40052 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
40053 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
40054 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
40055 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
40056 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
40057 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
40058 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40059 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
40060 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
40061 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
40062 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
40063 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40064 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
40065 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
40066 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
40067 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
40068 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
40069 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
40070 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
40071 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
40072 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
40073 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40074 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
40075 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40076 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
40077 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
40078 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
40080 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
40081 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
40082 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
40083 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40084 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
40085 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
40086 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40087 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40088 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40089 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40090 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40091 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40092 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40093 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40094 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40095 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40096 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40097 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40098 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40099 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40100 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40101 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40102 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40103 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40104 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40105 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40106 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40107 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40108 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40109 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40110 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40111 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40112 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40113 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40114 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40115 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40116 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40117 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40118 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40119 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40120 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40121 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40122 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40123 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40124 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40125 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40126 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40127 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40128 { (char *)"Clipboard_IsUsingPrimarySelection", (PyCFunction)_wrap_Clipboard_IsUsingPrimarySelection, METH_O, NULL},
40129 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40130 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40131 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40132 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40133 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40134 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40135 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40136 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40137 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40138 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40139 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40140 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40141 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40142 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40143 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40144 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40145 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40146 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40147 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40148 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40149 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40150 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40151 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40152 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40153 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40154 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40155 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40156 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40157 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40158 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40159 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40160 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40161 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40162 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40163 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40164 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40165 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40166 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40167 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40168 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40169 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40170 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40171 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40172 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40173 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40174 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40175 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40176 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40177 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40178 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40179 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40180 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40181 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40182 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40183 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40184 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40185 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40186 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40187 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40188 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40189 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40190 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40191 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40192 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40193 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40194 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40195 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40196 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40197 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40198 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40199 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40200 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40201 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40202 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40203 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40204 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40205 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40206 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40207 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40208 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40209 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40210 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40211 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40212 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40213 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40214 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40215 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40216 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40217 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40218 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40219 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40220 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40221 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40222 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40223 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40224 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40225 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40226 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40227 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40228 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40229 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40230 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40231 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40232 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40233 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40234 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40235 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40236 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40237 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40238 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40239 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40240 { NULL, NULL, 0, NULL }
40241 };
40242
40243
40244 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40245
40246 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40247 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40248 }
40249 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40250 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40251 }
40252 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40253 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40254 }
40255 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40256 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40257 }
40258 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40259 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40260 }
40261 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40262 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40263 }
40264 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40265 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40266 }
40267 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40268 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40269 }
40270 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40271 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40272 }
40273 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40274 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40275 }
40276 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40277 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40278 }
40279 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40280 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40281 }
40282 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40283 return (void *)((wxEvent *) ((wxPyEvent *) x));
40284 }
40285 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40286 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40287 }
40288 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40289 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40290 }
40291 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40292 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40293 }
40294 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40295 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40296 }
40297 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40298 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40299 }
40300 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40301 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40302 }
40303 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40304 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40305 }
40306 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40307 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40308 }
40309 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40310 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40311 }
40312 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40313 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40314 }
40315 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40316 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40317 }
40318 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40319 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40320 }
40321 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40322 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40323 }
40324 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40325 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40326 }
40327 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40328 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40329 }
40330 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40331 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40332 }
40333 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40334 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40335 }
40336 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40337 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40338 }
40339 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40340 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40341 }
40342 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40343 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40344 }
40345 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40346 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40347 }
40348 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40349 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40350 }
40351 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40352 return (void *)((wxEvent *) ((wxShowEvent *) x));
40353 }
40354 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40355 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40356 }
40357 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40358 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40359 }
40360 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40361 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40362 }
40363 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40364 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40365 }
40366 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40367 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40368 }
40369 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40370 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40371 }
40372 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40373 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40374 }
40375 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40376 return (void *)((wxConfigBase *) ((wxConfig *) x));
40377 }
40378 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40379 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40380 }
40381 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40382 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40383 }
40384 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40385 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40386 }
40387 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40388 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40389 }
40390 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40391 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40392 }
40393 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40394 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40395 }
40396 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40397 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40398 }
40399 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40400 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40401 }
40402 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40403 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40404 }
40405 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40406 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40407 }
40408 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40409 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40410 }
40411 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40412 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40413 }
40414 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40415 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40416 }
40417 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40418 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40419 }
40420 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40421 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40422 }
40423 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40424 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40425 }
40426 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40427 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40428 }
40429 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40430 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40431 }
40432 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40433 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40434 }
40435 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40436 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40437 }
40438 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40439 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40440 }
40441 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40442 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40443 }
40444 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40445 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40446 }
40447 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40448 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40449 }
40450 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40451 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40452 }
40453 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40454 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40455 }
40456 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40457 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40458 }
40459 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40460 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40461 }
40462 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40463 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40464 }
40465 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
40466 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
40467 }
40468 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40469 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40470 }
40471 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40472 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40473 }
40474 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40475 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40476 }
40477 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40478 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40479 }
40480 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
40481 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
40482 }
40483 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40484 return (void *)((wxObject *) ((wxSizerItem *) x));
40485 }
40486 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40487 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40488 }
40489 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40490 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40491 }
40492 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40493 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40494 }
40495 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40496 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40497 }
40498 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40499 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40500 }
40501 static void *_p_wxSizerTo_p_wxObject(void *x) {
40502 return (void *)((wxObject *) ((wxSizer *) x));
40503 }
40504 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40505 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40506 }
40507 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40508 return (void *)((wxObject *) ((wxFileHistory *) x));
40509 }
40510 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40511 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40512 }
40513 static void *_p_wxEventTo_p_wxObject(void *x) {
40514 return (void *)((wxObject *) ((wxEvent *) x));
40515 }
40516 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40517 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40518 }
40519 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40520 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40521 }
40522 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40523 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40524 }
40525 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40526 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40527 }
40528 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40529 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40530 }
40531 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40532 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40533 }
40534 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40535 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40536 }
40537 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40538 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40539 }
40540 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40541 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40542 }
40543 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40544 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40545 }
40546 static void *_p_wxControlTo_p_wxObject(void *x) {
40547 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40548 }
40549 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40550 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40551 }
40552 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40553 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40554 }
40555 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40556 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40557 }
40558 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40559 return (void *)((wxObject *) ((wxFSFile *) x));
40560 }
40561 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40562 return (void *)((wxObject *) ((wxClipboard *) x));
40563 }
40564 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40565 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40566 }
40567 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40568 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40569 }
40570 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40571 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40572 }
40573 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40574 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40575 }
40576 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40577 return (void *)((wxObject *) ((wxToolTip *) x));
40578 }
40579 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40580 return (void *)((wxObject *) ((wxMenuItem *) x));
40581 }
40582 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40583 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40584 }
40585 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40586 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40587 }
40588 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40589 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40590 }
40591 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40592 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40593 }
40594 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40595 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40596 }
40597 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40598 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40599 }
40600 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40601 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40602 }
40603 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40604 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40605 }
40606 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40607 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40608 }
40609 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40610 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40611 }
40612 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40613 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40614 }
40615 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40616 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40617 }
40618 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40619 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40620 }
40621 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40622 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40623 }
40624 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40625 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40626 }
40627 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40628 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40629 }
40630 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40631 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40632 }
40633 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40634 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40635 }
40636 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40637 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40638 }
40639 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40640 return (void *)((wxObject *) ((wxImageHandler *) x));
40641 }
40642 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40643 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40644 }
40645 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40646 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40647 }
40648 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40649 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40650 }
40651 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40652 return (void *)((wxObject *) ((wxEvtHandler *) x));
40653 }
40654 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40655 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40656 }
40657 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40658 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40659 }
40660 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40661 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40662 }
40663 static void *_p_wxImageTo_p_wxObject(void *x) {
40664 return (void *)((wxObject *) ((wxImage *) x));
40665 }
40666 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40667 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40668 }
40669 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40670 return (void *)((wxObject *) ((wxSystemOptions *) x));
40671 }
40672 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40673 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40674 }
40675 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40676 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40677 }
40678 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40679 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40680 }
40681 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40682 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40683 }
40684 static void *_p_wxWindowTo_p_wxObject(void *x) {
40685 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40686 }
40687 static void *_p_wxMenuTo_p_wxObject(void *x) {
40688 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40689 }
40690 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40691 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40692 }
40693 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40694 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40695 }
40696 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40697 return (void *)((wxObject *) ((wxFileSystem *) x));
40698 }
40699 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40700 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40701 }
40702 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40703 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40704 }
40705 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40706 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40707 }
40708 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40709 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40710 }
40711 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40712 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40713 }
40714 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40715 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40716 }
40717 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40718 return (void *)((wxObject *) ((wxBusyInfo *) x));
40719 }
40720 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40721 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40722 }
40723 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40724 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40725 }
40726 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40727 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40728 }
40729 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40730 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40731 }
40732 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40733 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40734 }
40735 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40736 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40737 }
40738 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40739 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40740 }
40741 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40742 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40743 }
40744 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40745 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40746 }
40747 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40748 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40749 }
40750 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40751 return (void *)((wxLog *) ((wxLogBuffer *) x));
40752 }
40753 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40754 return (void *)((wxLog *) ((wxLogStderr *) x));
40755 }
40756 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40757 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40758 }
40759 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40760 return (void *)((wxLog *) ((wxLogWindow *) x));
40761 }
40762 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40763 return (void *)((wxLog *) ((wxLogChain *) x));
40764 }
40765 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40766 return (void *)((wxLog *) ((wxLogGui *) x));
40767 }
40768 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40769 return (void *)((wxLog *) ((wxPyLog *) x));
40770 }
40771 static void *_p_wxControlTo_p_wxWindow(void *x) {
40772 return (void *)((wxWindow *) ((wxControl *) x));
40773 }
40774 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40775 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40776 }
40777 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40778 return (void *)((wxWindow *) ((wxMenuBar *) x));
40779 }
40780 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40781 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40782 }
40783 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40784 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40785 }
40786 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40787 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};
40788 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxArtClient = {"_p_wxArtClient", "wxArtClient *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxArtID = {"_p_wxArtID", "wxArtID *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40806 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40807 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40808 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40809 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40810 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40811 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40812 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40813 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40814 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40815 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40816 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40817 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40818 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40819 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40820 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40821 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40822 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40823 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40824 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40825 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40826 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40827 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40828 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40829 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40830 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40831 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40832 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40833 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40834 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40835 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40836 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40837 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40838 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40839 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40840 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40841 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40842 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40843 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40844 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40845 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40846 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40847 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40848 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40849 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40850 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40851 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40852 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40853 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40854 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40855 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40856 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40857 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40858 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40859 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40860 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40861 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40862 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40863 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40864 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40865 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40866 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40867 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", 0, 0, 0, 0, 0};
40868 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40869 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40870 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40871 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40872 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40873 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40874 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40875 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40876 static swig_type_info _swigt__p_wxIconBundle = {"_p_wxIconBundle", "wxIconBundle *", 0, 0, (void*)0, 0};
40877 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40878 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40879 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40880 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40881 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40882 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40883 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40884 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40885 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40886 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40887 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40888 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40889 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40890 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40891 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40892 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40893 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40894 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40895 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40896 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40897 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40898 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40899 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40900 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40901 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40902 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40903 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40904 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40905 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40906 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40907 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40908 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40909 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40910 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40911 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40912 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40913 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40914 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40915 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40916 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40917 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40918 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40919 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40920 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40921 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40922 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40923 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40924 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40925 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40926 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40927 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40928 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40929 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40930 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40931 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40932 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40933 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40934 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40935 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40936 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40937 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40938 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40939 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40940 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40941 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40942 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40943 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40944 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40945 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40946 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40947 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40948 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40949 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40950 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40951 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40952 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40953 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40954 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40955 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40956 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40957 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40958 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40959 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40960 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40961 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40962 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40963 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40964
40965 static swig_type_info *swig_type_initial[] = {
40966 &_swigt__p_char,
40967 &_swigt__p_form_ops_t,
40968 &_swigt__p_int,
40969 &_swigt__p_unsigned_char,
40970 &_swigt__p_unsigned_int,
40971 &_swigt__p_unsigned_long,
40972 &_swigt__p_void,
40973 &_swigt__p_wxANIHandler,
40974 &_swigt__p_wxAboutDialogInfo,
40975 &_swigt__p_wxAcceleratorTable,
40976 &_swigt__p_wxActivateEvent,
40977 &_swigt__p_wxArrayString,
40978 &_swigt__p_wxArtClient,
40979 &_swigt__p_wxArtID,
40980 &_swigt__p_wxBMPHandler,
40981 &_swigt__p_wxBitmap,
40982 &_swigt__p_wxBitmapDataObject,
40983 &_swigt__p_wxBoxSizer,
40984 &_swigt__p_wxBusyCursor,
40985 &_swigt__p_wxBusyInfo,
40986 &_swigt__p_wxCURHandler,
40987 &_swigt__p_wxCaret,
40988 &_swigt__p_wxChar,
40989 &_swigt__p_wxChildFocusEvent,
40990 &_swigt__p_wxClipboard,
40991 &_swigt__p_wxClipboardLocker,
40992 &_swigt__p_wxClipboardTextEvent,
40993 &_swigt__p_wxCloseEvent,
40994 &_swigt__p_wxColour,
40995 &_swigt__p_wxCommandEvent,
40996 &_swigt__p_wxConfig,
40997 &_swigt__p_wxConfigBase,
40998 &_swigt__p_wxConfigPathChanger,
40999 &_swigt__p_wxContextMenuEvent,
41000 &_swigt__p_wxControl,
41001 &_swigt__p_wxControlWithItems,
41002 &_swigt__p_wxCursor,
41003 &_swigt__p_wxCustomDataObject,
41004 &_swigt__p_wxDC,
41005 &_swigt__p_wxDataFormat,
41006 &_swigt__p_wxDataObject,
41007 &_swigt__p_wxDataObjectComposite,
41008 &_swigt__p_wxDataObjectSimple,
41009 &_swigt__p_wxDateEvent,
41010 &_swigt__p_wxDateSpan,
41011 &_swigt__p_wxDateTime,
41012 &_swigt__p_wxDateTime__TimeZone,
41013 &_swigt__p_wxDisplay,
41014 &_swigt__p_wxDisplayChangedEvent,
41015 &_swigt__p_wxDropFilesEvent,
41016 &_swigt__p_wxDuplexMode,
41017 &_swigt__p_wxEraseEvent,
41018 &_swigt__p_wxEvent,
41019 &_swigt__p_wxEventBlocker,
41020 &_swigt__p_wxEvtHandler,
41021 &_swigt__p_wxFSFile,
41022 &_swigt__p_wxFileConfig,
41023 &_swigt__p_wxFileDataObject,
41024 &_swigt__p_wxFileHistory,
41025 &_swigt__p_wxFileSystem,
41026 &_swigt__p_wxFileType,
41027 &_swigt__p_wxFileTypeInfo,
41028 &_swigt__p_wxFlexGridSizer,
41029 &_swigt__p_wxFocusEvent,
41030 &_swigt__p_wxFont,
41031 &_swigt__p_wxFrame,
41032 &_swigt__p_wxGBSizerItem,
41033 &_swigt__p_wxGIFHandler,
41034 &_swigt__p_wxGridBagSizer,
41035 &_swigt__p_wxGridSizer,
41036 &_swigt__p_wxICOHandler,
41037 &_swigt__p_wxIcon,
41038 &_swigt__p_wxIconBundle,
41039 &_swigt__p_wxIconizeEvent,
41040 &_swigt__p_wxIdleEvent,
41041 &_swigt__p_wxImage,
41042 &_swigt__p_wxImageHandler,
41043 &_swigt__p_wxIndividualLayoutConstraint,
41044 &_swigt__p_wxInitDialogEvent,
41045 &_swigt__p_wxJPEGHandler,
41046 &_swigt__p_wxJoystick,
41047 &_swigt__p_wxJoystickEvent,
41048 &_swigt__p_wxKeyEvent,
41049 &_swigt__p_wxKillError,
41050 &_swigt__p_wxLayoutConstraints,
41051 &_swigt__p_wxLog,
41052 &_swigt__p_wxLogBuffer,
41053 &_swigt__p_wxLogChain,
41054 &_swigt__p_wxLogGui,
41055 &_swigt__p_wxLogNull,
41056 &_swigt__p_wxLogStderr,
41057 &_swigt__p_wxLogTextCtrl,
41058 &_swigt__p_wxLogWindow,
41059 &_swigt__p_wxMaximizeEvent,
41060 &_swigt__p_wxMenu,
41061 &_swigt__p_wxMenuBar,
41062 &_swigt__p_wxMenuEvent,
41063 &_swigt__p_wxMenuItem,
41064 &_swigt__p_wxMetafileDataObject,
41065 &_swigt__p_wxMimeTypesManager,
41066 &_swigt__p_wxMouseCaptureChangedEvent,
41067 &_swigt__p_wxMouseCaptureLostEvent,
41068 &_swigt__p_wxMouseEvent,
41069 &_swigt__p_wxMouseState,
41070 &_swigt__p_wxMoveEvent,
41071 &_swigt__p_wxMutexGuiLocker,
41072 &_swigt__p_wxNavigationKeyEvent,
41073 &_swigt__p_wxNcPaintEvent,
41074 &_swigt__p_wxNotifyEvent,
41075 &_swigt__p_wxObject,
41076 &_swigt__p_wxOutputStream,
41077 &_swigt__p_wxPCXHandler,
41078 &_swigt__p_wxPNGHandler,
41079 &_swigt__p_wxPNMHandler,
41080 &_swigt__p_wxPaintEvent,
41081 &_swigt__p_wxPaletteChangedEvent,
41082 &_swigt__p_wxPaperSize,
41083 &_swigt__p_wxPlatformInfo,
41084 &_swigt__p_wxPoint,
41085 &_swigt__p_wxPowerEvent,
41086 &_swigt__p_wxProcessEvent,
41087 &_swigt__p_wxPyApp,
41088 &_swigt__p_wxPyArtProvider,
41089 &_swigt__p_wxPyBitmapDataObject,
41090 &_swigt__p_wxPyCommandEvent,
41091 &_swigt__p_wxPyDataObjectSimple,
41092 &_swigt__p_wxPyDropSource,
41093 &_swigt__p_wxPyDropTarget,
41094 &_swigt__p_wxPyEvent,
41095 &_swigt__p_wxPyFileDropTarget,
41096 &_swigt__p_wxPyImageHandler,
41097 &_swigt__p_wxPyLog,
41098 &_swigt__p_wxPyProcess,
41099 &_swigt__p_wxPySizer,
41100 &_swigt__p_wxPyTextDataObject,
41101 &_swigt__p_wxPyTextDropTarget,
41102 &_swigt__p_wxPyTimer,
41103 &_swigt__p_wxPyTipProvider,
41104 &_swigt__p_wxPyValidator,
41105 &_swigt__p_wxQueryNewPaletteEvent,
41106 &_swigt__p_wxRect,
41107 &_swigt__p_wxScrollEvent,
41108 &_swigt__p_wxScrollWinEvent,
41109 &_swigt__p_wxSetCursorEvent,
41110 &_swigt__p_wxShowEvent,
41111 &_swigt__p_wxSingleInstanceChecker,
41112 &_swigt__p_wxSize,
41113 &_swigt__p_wxSizeEvent,
41114 &_swigt__p_wxSizer,
41115 &_swigt__p_wxSizerItem,
41116 &_swigt__p_wxSound,
41117 &_swigt__p_wxStandardPaths,
41118 &_swigt__p_wxStaticBoxSizer,
41119 &_swigt__p_wxStdDialogButtonSizer,
41120 &_swigt__p_wxStopWatch,
41121 &_swigt__p_wxString,
41122 &_swigt__p_wxSysColourChangedEvent,
41123 &_swigt__p_wxSystemOptions,
41124 &_swigt__p_wxSystemSettings,
41125 &_swigt__p_wxTGAHandler,
41126 &_swigt__p_wxTIFFHandler,
41127 &_swigt__p_wxTextCtrl,
41128 &_swigt__p_wxTextDataObject,
41129 &_swigt__p_wxTimeSpan,
41130 &_swigt__p_wxTimer,
41131 &_swigt__p_wxTimerEvent,
41132 &_swigt__p_wxTimerRunner,
41133 &_swigt__p_wxTipProvider,
41134 &_swigt__p_wxToolTip,
41135 &_swigt__p_wxURLDataObject,
41136 &_swigt__p_wxUpdateUIEvent,
41137 &_swigt__p_wxValidator,
41138 &_swigt__p_wxVideoMode,
41139 &_swigt__p_wxWindow,
41140 &_swigt__p_wxWindowCreateEvent,
41141 &_swigt__p_wxWindowDestroyEvent,
41142 &_swigt__p_wxWindowDisabler,
41143 &_swigt__p_wxXPMHandler,
41144 };
41145
41146 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxArtClient[] = { {&_swigt__p_wxArtClient, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxArtID[] = { {&_swigt__p_wxArtID, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41158 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}};
41159 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41167 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}};
41168 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41173 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}};
41174 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41175 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}};
41176 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41179 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41189 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41190 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41207 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41208 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41212 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41213 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41216 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41217 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41218 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41219 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}};
41220 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41221 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41222 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41223 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41224 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41225 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41226 static swig_cast_info _swigc__p_wxEventBlocker[] = {{&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
41227 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41228 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41229 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41230 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41231 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41232 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41233 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41234 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41235 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41236 static swig_cast_info _swigc__p_wxIconBundle[] = { {&_swigt__p_wxIconBundle, 0, 0, 0},{0, 0, 0, 0}};
41237 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41238 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41239 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41240 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}};
41241 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41242 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41243 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41244 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41245 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41246 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41247 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41248 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41249 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41250 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41251 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41252 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41253 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41254 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41255 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41256 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41257 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41258 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41259 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41260 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41261 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41262 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41263 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41264 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41265 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41266 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41267 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41268 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41269 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41270 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41271 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41272 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41273 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41274 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41275 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41276 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41277 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41278 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41279 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41280 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41281 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41282 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41283 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41284 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
41285 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41286 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41287 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41288 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41289 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41290 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41291 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41292 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41293 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41294 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41295 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}};
41296 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41297 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41298 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41299 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41300 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41301 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41302 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41303 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41304 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41305 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41306 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41307 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41308 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41309 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41310 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41311 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41312 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41313 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}};
41314 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41315 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41316 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41317 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41318 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}};
41319 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41320 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41321 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41322 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}};
41323 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41324
41325 static swig_cast_info *swig_cast_initial[] = {
41326 _swigc__p_char,
41327 _swigc__p_form_ops_t,
41328 _swigc__p_int,
41329 _swigc__p_unsigned_char,
41330 _swigc__p_unsigned_int,
41331 _swigc__p_unsigned_long,
41332 _swigc__p_void,
41333 _swigc__p_wxANIHandler,
41334 _swigc__p_wxAboutDialogInfo,
41335 _swigc__p_wxAcceleratorTable,
41336 _swigc__p_wxActivateEvent,
41337 _swigc__p_wxArrayString,
41338 _swigc__p_wxArtClient,
41339 _swigc__p_wxArtID,
41340 _swigc__p_wxBMPHandler,
41341 _swigc__p_wxBitmap,
41342 _swigc__p_wxBitmapDataObject,
41343 _swigc__p_wxBoxSizer,
41344 _swigc__p_wxBusyCursor,
41345 _swigc__p_wxBusyInfo,
41346 _swigc__p_wxCURHandler,
41347 _swigc__p_wxCaret,
41348 _swigc__p_wxChar,
41349 _swigc__p_wxChildFocusEvent,
41350 _swigc__p_wxClipboard,
41351 _swigc__p_wxClipboardLocker,
41352 _swigc__p_wxClipboardTextEvent,
41353 _swigc__p_wxCloseEvent,
41354 _swigc__p_wxColour,
41355 _swigc__p_wxCommandEvent,
41356 _swigc__p_wxConfig,
41357 _swigc__p_wxConfigBase,
41358 _swigc__p_wxConfigPathChanger,
41359 _swigc__p_wxContextMenuEvent,
41360 _swigc__p_wxControl,
41361 _swigc__p_wxControlWithItems,
41362 _swigc__p_wxCursor,
41363 _swigc__p_wxCustomDataObject,
41364 _swigc__p_wxDC,
41365 _swigc__p_wxDataFormat,
41366 _swigc__p_wxDataObject,
41367 _swigc__p_wxDataObjectComposite,
41368 _swigc__p_wxDataObjectSimple,
41369 _swigc__p_wxDateEvent,
41370 _swigc__p_wxDateSpan,
41371 _swigc__p_wxDateTime,
41372 _swigc__p_wxDateTime__TimeZone,
41373 _swigc__p_wxDisplay,
41374 _swigc__p_wxDisplayChangedEvent,
41375 _swigc__p_wxDropFilesEvent,
41376 _swigc__p_wxDuplexMode,
41377 _swigc__p_wxEraseEvent,
41378 _swigc__p_wxEvent,
41379 _swigc__p_wxEventBlocker,
41380 _swigc__p_wxEvtHandler,
41381 _swigc__p_wxFSFile,
41382 _swigc__p_wxFileConfig,
41383 _swigc__p_wxFileDataObject,
41384 _swigc__p_wxFileHistory,
41385 _swigc__p_wxFileSystem,
41386 _swigc__p_wxFileType,
41387 _swigc__p_wxFileTypeInfo,
41388 _swigc__p_wxFlexGridSizer,
41389 _swigc__p_wxFocusEvent,
41390 _swigc__p_wxFont,
41391 _swigc__p_wxFrame,
41392 _swigc__p_wxGBSizerItem,
41393 _swigc__p_wxGIFHandler,
41394 _swigc__p_wxGridBagSizer,
41395 _swigc__p_wxGridSizer,
41396 _swigc__p_wxICOHandler,
41397 _swigc__p_wxIcon,
41398 _swigc__p_wxIconBundle,
41399 _swigc__p_wxIconizeEvent,
41400 _swigc__p_wxIdleEvent,
41401 _swigc__p_wxImage,
41402 _swigc__p_wxImageHandler,
41403 _swigc__p_wxIndividualLayoutConstraint,
41404 _swigc__p_wxInitDialogEvent,
41405 _swigc__p_wxJPEGHandler,
41406 _swigc__p_wxJoystick,
41407 _swigc__p_wxJoystickEvent,
41408 _swigc__p_wxKeyEvent,
41409 _swigc__p_wxKillError,
41410 _swigc__p_wxLayoutConstraints,
41411 _swigc__p_wxLog,
41412 _swigc__p_wxLogBuffer,
41413 _swigc__p_wxLogChain,
41414 _swigc__p_wxLogGui,
41415 _swigc__p_wxLogNull,
41416 _swigc__p_wxLogStderr,
41417 _swigc__p_wxLogTextCtrl,
41418 _swigc__p_wxLogWindow,
41419 _swigc__p_wxMaximizeEvent,
41420 _swigc__p_wxMenu,
41421 _swigc__p_wxMenuBar,
41422 _swigc__p_wxMenuEvent,
41423 _swigc__p_wxMenuItem,
41424 _swigc__p_wxMetafileDataObject,
41425 _swigc__p_wxMimeTypesManager,
41426 _swigc__p_wxMouseCaptureChangedEvent,
41427 _swigc__p_wxMouseCaptureLostEvent,
41428 _swigc__p_wxMouseEvent,
41429 _swigc__p_wxMouseState,
41430 _swigc__p_wxMoveEvent,
41431 _swigc__p_wxMutexGuiLocker,
41432 _swigc__p_wxNavigationKeyEvent,
41433 _swigc__p_wxNcPaintEvent,
41434 _swigc__p_wxNotifyEvent,
41435 _swigc__p_wxObject,
41436 _swigc__p_wxOutputStream,
41437 _swigc__p_wxPCXHandler,
41438 _swigc__p_wxPNGHandler,
41439 _swigc__p_wxPNMHandler,
41440 _swigc__p_wxPaintEvent,
41441 _swigc__p_wxPaletteChangedEvent,
41442 _swigc__p_wxPaperSize,
41443 _swigc__p_wxPlatformInfo,
41444 _swigc__p_wxPoint,
41445 _swigc__p_wxPowerEvent,
41446 _swigc__p_wxProcessEvent,
41447 _swigc__p_wxPyApp,
41448 _swigc__p_wxPyArtProvider,
41449 _swigc__p_wxPyBitmapDataObject,
41450 _swigc__p_wxPyCommandEvent,
41451 _swigc__p_wxPyDataObjectSimple,
41452 _swigc__p_wxPyDropSource,
41453 _swigc__p_wxPyDropTarget,
41454 _swigc__p_wxPyEvent,
41455 _swigc__p_wxPyFileDropTarget,
41456 _swigc__p_wxPyImageHandler,
41457 _swigc__p_wxPyLog,
41458 _swigc__p_wxPyProcess,
41459 _swigc__p_wxPySizer,
41460 _swigc__p_wxPyTextDataObject,
41461 _swigc__p_wxPyTextDropTarget,
41462 _swigc__p_wxPyTimer,
41463 _swigc__p_wxPyTipProvider,
41464 _swigc__p_wxPyValidator,
41465 _swigc__p_wxQueryNewPaletteEvent,
41466 _swigc__p_wxRect,
41467 _swigc__p_wxScrollEvent,
41468 _swigc__p_wxScrollWinEvent,
41469 _swigc__p_wxSetCursorEvent,
41470 _swigc__p_wxShowEvent,
41471 _swigc__p_wxSingleInstanceChecker,
41472 _swigc__p_wxSize,
41473 _swigc__p_wxSizeEvent,
41474 _swigc__p_wxSizer,
41475 _swigc__p_wxSizerItem,
41476 _swigc__p_wxSound,
41477 _swigc__p_wxStandardPaths,
41478 _swigc__p_wxStaticBoxSizer,
41479 _swigc__p_wxStdDialogButtonSizer,
41480 _swigc__p_wxStopWatch,
41481 _swigc__p_wxString,
41482 _swigc__p_wxSysColourChangedEvent,
41483 _swigc__p_wxSystemOptions,
41484 _swigc__p_wxSystemSettings,
41485 _swigc__p_wxTGAHandler,
41486 _swigc__p_wxTIFFHandler,
41487 _swigc__p_wxTextCtrl,
41488 _swigc__p_wxTextDataObject,
41489 _swigc__p_wxTimeSpan,
41490 _swigc__p_wxTimer,
41491 _swigc__p_wxTimerEvent,
41492 _swigc__p_wxTimerRunner,
41493 _swigc__p_wxTipProvider,
41494 _swigc__p_wxToolTip,
41495 _swigc__p_wxURLDataObject,
41496 _swigc__p_wxUpdateUIEvent,
41497 _swigc__p_wxValidator,
41498 _swigc__p_wxVideoMode,
41499 _swigc__p_wxWindow,
41500 _swigc__p_wxWindowCreateEvent,
41501 _swigc__p_wxWindowDestroyEvent,
41502 _swigc__p_wxWindowDisabler,
41503 _swigc__p_wxXPMHandler,
41504 };
41505
41506
41507 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41508
41509 static swig_const_info swig_const_table[] = {
41510 {0, 0, 0, 0.0, 0, 0}};
41511
41512 #ifdef __cplusplus
41513 }
41514 #endif
41515 /* -----------------------------------------------------------------------------
41516 * Type initialization:
41517 * This problem is tough by the requirement that no dynamic
41518 * memory is used. Also, since swig_type_info structures store pointers to
41519 * swig_cast_info structures and swig_cast_info structures store pointers back
41520 * to swig_type_info structures, we need some lookup code at initialization.
41521 * The idea is that swig generates all the structures that are needed.
41522 * The runtime then collects these partially filled structures.
41523 * The SWIG_InitializeModule function takes these initial arrays out of
41524 * swig_module, and does all the lookup, filling in the swig_module.types
41525 * array with the correct data and linking the correct swig_cast_info
41526 * structures together.
41527 *
41528 * The generated swig_type_info structures are assigned staticly to an initial
41529 * array. We just loop though that array, and handle each type individually.
41530 * First we lookup if this type has been already loaded, and if so, use the
41531 * loaded structure instead of the generated one. Then we have to fill in the
41532 * cast linked list. The cast data is initially stored in something like a
41533 * two-dimensional array. Each row corresponds to a type (there are the same
41534 * number of rows as there are in the swig_type_initial array). Each entry in
41535 * a column is one of the swig_cast_info structures for that type.
41536 * The cast_initial array is actually an array of arrays, because each row has
41537 * a variable number of columns. So to actually build the cast linked list,
41538 * we find the array of casts associated with the type, and loop through it
41539 * adding the casts to the list. The one last trick we need to do is making
41540 * sure the type pointer in the swig_cast_info struct is correct.
41541 *
41542 * First off, we lookup the cast->type name to see if it is already loaded.
41543 * There are three cases to handle:
41544 * 1) If the cast->type has already been loaded AND the type we are adding
41545 * casting info to has not been loaded (it is in this module), THEN we
41546 * replace the cast->type pointer with the type pointer that has already
41547 * been loaded.
41548 * 2) If BOTH types (the one we are adding casting info to, and the
41549 * cast->type) are loaded, THEN the cast info has already been loaded by
41550 * the previous module so we just ignore it.
41551 * 3) Finally, if cast->type has not already been loaded, then we add that
41552 * swig_cast_info to the linked list (because the cast->type) pointer will
41553 * be correct.
41554 * ----------------------------------------------------------------------------- */
41555
41556 #ifdef __cplusplus
41557 extern "C" {
41558 #if 0
41559 } /* c-mode */
41560 #endif
41561 #endif
41562
41563 #if 0
41564 #define SWIGRUNTIME_DEBUG
41565 #endif
41566
41567 SWIGRUNTIME void
41568 SWIG_InitializeModule(void *clientdata) {
41569 size_t i;
41570 swig_module_info *module_head;
41571 static int init_run = 0;
41572
41573 clientdata = clientdata;
41574
41575 if (init_run) return;
41576 init_run = 1;
41577
41578 /* Initialize the swig_module */
41579 swig_module.type_initial = swig_type_initial;
41580 swig_module.cast_initial = swig_cast_initial;
41581
41582 /* Try and load any already created modules */
41583 module_head = SWIG_GetModule(clientdata);
41584 if (module_head) {
41585 swig_module.next = module_head->next;
41586 module_head->next = &swig_module;
41587 } else {
41588 /* This is the first module loaded */
41589 swig_module.next = &swig_module;
41590 SWIG_SetModule(clientdata, &swig_module);
41591 }
41592
41593 /* Now work on filling in swig_module.types */
41594 #ifdef SWIGRUNTIME_DEBUG
41595 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41596 #endif
41597 for (i = 0; i < swig_module.size; ++i) {
41598 swig_type_info *type = 0;
41599 swig_type_info *ret;
41600 swig_cast_info *cast;
41601
41602 #ifdef SWIGRUNTIME_DEBUG
41603 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41604 #endif
41605
41606 /* if there is another module already loaded */
41607 if (swig_module.next != &swig_module) {
41608 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41609 }
41610 if (type) {
41611 /* Overwrite clientdata field */
41612 #ifdef SWIGRUNTIME_DEBUG
41613 printf("SWIG_InitializeModule: found type %s\n", type->name);
41614 #endif
41615 if (swig_module.type_initial[i]->clientdata) {
41616 type->clientdata = swig_module.type_initial[i]->clientdata;
41617 #ifdef SWIGRUNTIME_DEBUG
41618 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41619 #endif
41620 }
41621 } else {
41622 type = swig_module.type_initial[i];
41623 }
41624
41625 /* Insert casting types */
41626 cast = swig_module.cast_initial[i];
41627 while (cast->type) {
41628 /* Don't need to add information already in the list */
41629 ret = 0;
41630 #ifdef SWIGRUNTIME_DEBUG
41631 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41632 #endif
41633 if (swig_module.next != &swig_module) {
41634 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41635 #ifdef SWIGRUNTIME_DEBUG
41636 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41637 #endif
41638 }
41639 if (ret) {
41640 if (type == swig_module.type_initial[i]) {
41641 #ifdef SWIGRUNTIME_DEBUG
41642 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41643 #endif
41644 cast->type = ret;
41645 ret = 0;
41646 } else {
41647 /* Check for casting already in the list */
41648 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41649 #ifdef SWIGRUNTIME_DEBUG
41650 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41651 #endif
41652 if (!ocast) ret = 0;
41653 }
41654 }
41655
41656 if (!ret) {
41657 #ifdef SWIGRUNTIME_DEBUG
41658 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41659 #endif
41660 if (type->cast) {
41661 type->cast->prev = cast;
41662 cast->next = type->cast;
41663 }
41664 type->cast = cast;
41665 }
41666 cast++;
41667 }
41668 /* Set entry in modules->types array equal to the type */
41669 swig_module.types[i] = type;
41670 }
41671 swig_module.types[i] = 0;
41672
41673 #ifdef SWIGRUNTIME_DEBUG
41674 printf("**** SWIG_InitializeModule: Cast List ******\n");
41675 for (i = 0; i < swig_module.size; ++i) {
41676 int j = 0;
41677 swig_cast_info *cast = swig_module.cast_initial[i];
41678 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41679 while (cast->type) {
41680 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41681 cast++;
41682 ++j;
41683 }
41684 printf("---- Total casts: %d\n",j);
41685 }
41686 printf("**** SWIG_InitializeModule: Cast List ******\n");
41687 #endif
41688 }
41689
41690 /* This function will propagate the clientdata field of type to
41691 * any new swig_type_info structures that have been added into the list
41692 * of equivalent types. It is like calling
41693 * SWIG_TypeClientData(type, clientdata) a second time.
41694 */
41695 SWIGRUNTIME void
41696 SWIG_PropagateClientData(void) {
41697 size_t i;
41698 swig_cast_info *equiv;
41699 static int init_run = 0;
41700
41701 if (init_run) return;
41702 init_run = 1;
41703
41704 for (i = 0; i < swig_module.size; i++) {
41705 if (swig_module.types[i]->clientdata) {
41706 equiv = swig_module.types[i]->cast;
41707 while (equiv) {
41708 if (!equiv->converter) {
41709 if (equiv->type && !equiv->type->clientdata)
41710 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41711 }
41712 equiv = equiv->next;
41713 }
41714 }
41715 }
41716 }
41717
41718 #ifdef __cplusplus
41719 #if 0
41720 {
41721 /* c-mode */
41722 #endif
41723 }
41724 #endif
41725
41726
41727
41728 #ifdef __cplusplus
41729 extern "C" {
41730 #endif
41731
41732 /* Python-specific SWIG API */
41733 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41734 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41735 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41736
41737 /* -----------------------------------------------------------------------------
41738 * global variable support code.
41739 * ----------------------------------------------------------------------------- */
41740
41741 typedef struct swig_globalvar {
41742 char *name; /* Name of global variable */
41743 PyObject *(*get_attr)(void); /* Return the current value */
41744 int (*set_attr)(PyObject *); /* Set the value */
41745 struct swig_globalvar *next;
41746 } swig_globalvar;
41747
41748 typedef struct swig_varlinkobject {
41749 PyObject_HEAD
41750 swig_globalvar *vars;
41751 } swig_varlinkobject;
41752
41753 SWIGINTERN PyObject *
41754 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41755 return PyString_FromString("<Swig global variables>");
41756 }
41757
41758 SWIGINTERN PyObject *
41759 swig_varlink_str(swig_varlinkobject *v) {
41760 PyObject *str = PyString_FromString("(");
41761 swig_globalvar *var;
41762 for (var = v->vars; var; var=var->next) {
41763 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41764 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41765 }
41766 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41767 return str;
41768 }
41769
41770 SWIGINTERN int
41771 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41772 PyObject *str = swig_varlink_str(v);
41773 fprintf(fp,"Swig global variables ");
41774 fprintf(fp,"%s\n", PyString_AsString(str));
41775 Py_DECREF(str);
41776 return 0;
41777 }
41778
41779 SWIGINTERN void
41780 swig_varlink_dealloc(swig_varlinkobject *v) {
41781 swig_globalvar *var = v->vars;
41782 while (var) {
41783 swig_globalvar *n = var->next;
41784 free(var->name);
41785 free(var);
41786 var = n;
41787 }
41788 }
41789
41790 SWIGINTERN PyObject *
41791 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41792 PyObject *res = NULL;
41793 swig_globalvar *var = v->vars;
41794 while (var) {
41795 if (strcmp(var->name,n) == 0) {
41796 res = (*var->get_attr)();
41797 break;
41798 }
41799 var = var->next;
41800 }
41801 if (res == NULL && !PyErr_Occurred()) {
41802 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41803 }
41804 return res;
41805 }
41806
41807 SWIGINTERN int
41808 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41809 int res = 1;
41810 swig_globalvar *var = v->vars;
41811 while (var) {
41812 if (strcmp(var->name,n) == 0) {
41813 res = (*var->set_attr)(p);
41814 break;
41815 }
41816 var = var->next;
41817 }
41818 if (res == 1 && !PyErr_Occurred()) {
41819 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41820 }
41821 return res;
41822 }
41823
41824 SWIGINTERN PyTypeObject*
41825 swig_varlink_type(void) {
41826 static char varlink__doc__[] = "Swig var link object";
41827 static PyTypeObject varlink_type;
41828 static int type_init = 0;
41829 if (!type_init) {
41830 const PyTypeObject tmp
41831 = {
41832 PyObject_HEAD_INIT(NULL)
41833 0, /* Number of items in variable part (ob_size) */
41834 (char *)"swigvarlink", /* Type name (tp_name) */
41835 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41836 0, /* Itemsize (tp_itemsize) */
41837 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41838 (printfunc) swig_varlink_print, /* Print (tp_print) */
41839 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41840 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41841 0, /* tp_compare */
41842 (reprfunc) swig_varlink_repr, /* tp_repr */
41843 0, /* tp_as_number */
41844 0, /* tp_as_sequence */
41845 0, /* tp_as_mapping */
41846 0, /* tp_hash */
41847 0, /* tp_call */
41848 (reprfunc)swig_varlink_str, /* tp_str */
41849 0, /* tp_getattro */
41850 0, /* tp_setattro */
41851 0, /* tp_as_buffer */
41852 0, /* tp_flags */
41853 varlink__doc__, /* tp_doc */
41854 0, /* tp_traverse */
41855 0, /* tp_clear */
41856 0, /* tp_richcompare */
41857 0, /* tp_weaklistoffset */
41858 #if PY_VERSION_HEX >= 0x02020000
41859 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41860 #endif
41861 #if PY_VERSION_HEX >= 0x02030000
41862 0, /* tp_del */
41863 #endif
41864 #ifdef COUNT_ALLOCS
41865 0,0,0,0 /* tp_alloc -> tp_next */
41866 #endif
41867 };
41868 varlink_type = tmp;
41869 varlink_type.ob_type = &PyType_Type;
41870 type_init = 1;
41871 }
41872 return &varlink_type;
41873 }
41874
41875 /* Create a variable linking object for use later */
41876 SWIGINTERN PyObject *
41877 SWIG_Python_newvarlink(void) {
41878 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41879 if (result) {
41880 result->vars = 0;
41881 }
41882 return ((PyObject*) result);
41883 }
41884
41885 SWIGINTERN void
41886 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41887 swig_varlinkobject *v = (swig_varlinkobject *) p;
41888 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41889 if (gv) {
41890 size_t size = strlen(name)+1;
41891 gv->name = (char *)malloc(size);
41892 if (gv->name) {
41893 strncpy(gv->name,name,size);
41894 gv->get_attr = get_attr;
41895 gv->set_attr = set_attr;
41896 gv->next = v->vars;
41897 }
41898 }
41899 v->vars = gv;
41900 }
41901
41902 SWIGINTERN PyObject *
41903 SWIG_globals() {
41904 static PyObject *_SWIG_globals = 0;
41905 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41906 return _SWIG_globals;
41907 }
41908
41909 /* -----------------------------------------------------------------------------
41910 * constants/methods manipulation
41911 * ----------------------------------------------------------------------------- */
41912
41913 /* Install Constants */
41914 SWIGINTERN void
41915 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41916 PyObject *obj = 0;
41917 size_t i;
41918 for (i = 0; constants[i].type; ++i) {
41919 switch(constants[i].type) {
41920 case SWIG_PY_POINTER:
41921 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41922 break;
41923 case SWIG_PY_BINARY:
41924 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41925 break;
41926 default:
41927 obj = 0;
41928 break;
41929 }
41930 if (obj) {
41931 PyDict_SetItemString(d, constants[i].name, obj);
41932 Py_DECREF(obj);
41933 }
41934 }
41935 }
41936
41937 /* -----------------------------------------------------------------------------*/
41938 /* Fix SwigMethods to carry the callback ptrs when needed */
41939 /* -----------------------------------------------------------------------------*/
41940
41941 SWIGINTERN void
41942 SWIG_Python_FixMethods(PyMethodDef *methods,
41943 swig_const_info *const_table,
41944 swig_type_info **types,
41945 swig_type_info **types_initial) {
41946 size_t i;
41947 for (i = 0; methods[i].ml_name; ++i) {
41948 const char *c = methods[i].ml_doc;
41949 if (c && (c = strstr(c, "swig_ptr: "))) {
41950 int j;
41951 swig_const_info *ci = 0;
41952 const char *name = c + 10;
41953 for (j = 0; const_table[j].type; ++j) {
41954 if (strncmp(const_table[j].name, name,
41955 strlen(const_table[j].name)) == 0) {
41956 ci = &(const_table[j]);
41957 break;
41958 }
41959 }
41960 if (ci) {
41961 size_t shift = (ci->ptype) - types;
41962 swig_type_info *ty = types_initial[shift];
41963 size_t ldoc = (c - methods[i].ml_doc);
41964 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41965 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41966 if (ndoc) {
41967 char *buff = ndoc;
41968 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41969 if (ptr) {
41970 strncpy(buff, methods[i].ml_doc, ldoc);
41971 buff += ldoc;
41972 strncpy(buff, "swig_ptr: ", 10);
41973 buff += 10;
41974 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41975 methods[i].ml_doc = ndoc;
41976 }
41977 }
41978 }
41979 }
41980 }
41981 }
41982
41983 #ifdef __cplusplus
41984 }
41985 #endif
41986
41987 /* -----------------------------------------------------------------------------*
41988 * Partial Init method
41989 * -----------------------------------------------------------------------------*/
41990
41991 #ifdef __cplusplus
41992 extern "C"
41993 #endif
41994 SWIGEXPORT void SWIG_init(void) {
41995 PyObject *m, *d;
41996
41997 /* Fix SwigMethods to carry the callback ptrs when needed */
41998 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41999
42000 m = Py_InitModule((char *) SWIG_name, SwigMethods);
42001 d = PyModule_GetDict(m);
42002
42003 SWIG_InitializeModule(0);
42004 SWIG_InstallConstants(d,swig_const_table);
42005
42006
42007 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
42008 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
42009 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
42010 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
42011 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
42012 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
42013 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
42014 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
42015 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
42016 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
42017 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
42018 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
42019 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
42020 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
42021 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
42022 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
42023 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
42024 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
42025 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
42026 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
42027 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
42028 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
42029 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
42030 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
42031 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
42032 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
42033 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
42034 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
42035 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
42036 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
42037 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
42038 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
42039 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
42040 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
42041 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
42042 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
42043 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
42044 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
42045 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
42046 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
42047 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
42048 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
42049 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
42050 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
42051 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
42052 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
42053 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
42054 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
42055 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
42056 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
42057 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
42058 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
42059 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
42060 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
42061 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
42062 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
42063 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
42064 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
42065 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
42066 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
42067 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
42068 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
42069 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
42070 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
42071 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
42072 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
42073 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
42074 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
42075 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
42076 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
42077 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
42078 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
42079 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
42080 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
42081 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
42082 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
42083 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
42084 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
42085 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
42086 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
42087 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
42088 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
42089 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
42090 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
42091 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
42092 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
42093 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
42094 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
42095 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
42096 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
42097 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
42098 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
42099 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
42100 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
42101 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
42102 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
42103 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
42104 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
42105 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
42106 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
42107 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
42108 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
42109 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42110 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42111 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42112 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42113 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42114 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42115 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42116 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42117 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42118 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42119 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42120 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42121 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42122 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42123 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42124 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42125 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42126 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42127 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42128 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42129 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42130 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42131 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42132 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42133 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42134 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42135 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42136 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42137 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42138 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42139 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42140 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42141 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42142 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42143 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42144 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42145 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42146 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42147 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42148 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42149 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42150 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42151 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42152 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42153 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42154 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42155
42156 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42157
42158 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42159 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42160 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42161 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42162 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42163 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42164 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42165 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42166 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42167 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42168 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42169 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42170 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42171 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42172 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42173 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42174 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42175 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42176 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42177 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42178 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42179 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42180 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42181 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42182 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42183 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42184 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42185 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42186 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42187 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42188 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42189 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42190 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42191 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42192 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42193 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42194 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42195 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42196 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42197 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42198 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42199 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42200 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42201 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42202 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42203 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42204 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42205 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42206 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42207 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42208 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42209 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42210 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42211 SWIG_Python_SetConstant(d, "EXEC_NOEVENTS",SWIG_From_int(static_cast< int >(wxEXEC_NOEVENTS)));
42212 SWIG_Python_SetConstant(d, "EXEC_BLOCK",SWIG_From_int(static_cast< int >(wxEXEC_BLOCK)));
42213
42214 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42215
42216 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42217 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42218 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42219 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42220 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42221 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42222 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42223 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42224 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42225 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42226 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42227 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42228 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42229 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42230 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42231 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42232 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42233 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42234 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42235 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42236 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42237 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42238 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42239 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42240 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42241 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42242 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42243 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST",ART_LIST_get, ART_LIST_set);
42244 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42245 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42246 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42247 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42248 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42249 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42250 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42251 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42252 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42253 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42254 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42255 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42256 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42257 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42258 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42259 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42260 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42261 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42262 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42263 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42264 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42265 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42266 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42267 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42268 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42269 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42270 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42271 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42272 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42273 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42274 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42275 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42276 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42277 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42278 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42279 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42280 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42281 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42282 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42283 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42284 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42285 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42286 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42287 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42288 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42289 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42290 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42291 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42292 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42293
42294 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42295
42296 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42297 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42298 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42299 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42300 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42301 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42302 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42303 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42304 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42305 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42306 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42307 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42308 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42309 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42310 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42311 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42312 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42313 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42314 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42315 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42316 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42317 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42318 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42319 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42320 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42321 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42322 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42323 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42324 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42325 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42326 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42327 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42328 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42329 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42330 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42331 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42332 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42333 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42334 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42335 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42336 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42337 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42338 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42339 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42340 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42341 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42342 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42343 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42344 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42345 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42346 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42347 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42348 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42349 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42350 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42351 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42352 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42353 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42354 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42355 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42356 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42357 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42358 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42359 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42360 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42361 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42362 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42363 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42364 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42365 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42366 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42367 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42368 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42369 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42370 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42371 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42372 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42373 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42374 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42375 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42376 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42377 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42378 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42379 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42380 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42381 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42382 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42383 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42384 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42385 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42386 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42387 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42388 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42389 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42390 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42391 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42392 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42393 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42394 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42395 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42396 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42397 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42398 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42399 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42400 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42401 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42402 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42403 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42404 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42405 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42406 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42407 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42408 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42409 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42410 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42411 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42412 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42413 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42414 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42415 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42416 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42417 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42418 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42419 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42420 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42421 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42422 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42423 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42424 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42425 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42426 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42427 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42428 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42429 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42430 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42431 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42432 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42433 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42434 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42435 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42436 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42437 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42438 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42439 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42440 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42441 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42442 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42443 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42444 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42445 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42446 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42447 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42448 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42449 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42450 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42451 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42452 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42453 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42454 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42455 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42456 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42457 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42458 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42459 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42460 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42461 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42462 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42463 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42464 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42465 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42466 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42467 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42468 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42469 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42470 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42471 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42472 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42473 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42474 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42475 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42476 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42477 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42478 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42479 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42480 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42481 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42482 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42483 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42484 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42485 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42486 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42487 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42488 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42489 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42490 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42491 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42492 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42493 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42494 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42495 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42496 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42497 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42498 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42499
42500 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42501 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42502 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42503 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42504
42505 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42506 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42507 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42508 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42509 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42510 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42511 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42512 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42513 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42514 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42515 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42516 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42517 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42518 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42519 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42520 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42521 }
42522
wxWidgets (Impactor)