]> 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
test changing of selected item's icon in DoToggleIcon as well
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_char swig_types[0]
2467 #define SWIGTYPE_p_form_ops_t swig_types[1]
2468 #define SWIGTYPE_p_int swig_types[2]
2469 #define SWIGTYPE_p_unsigned_char swig_types[3]
2470 #define SWIGTYPE_p_unsigned_int swig_types[4]
2471 #define SWIGTYPE_p_unsigned_long swig_types[5]
2472 #define SWIGTYPE_p_void swig_types[6]
2473 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2474 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMemorySize swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseState swig_types[98]
2565 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2567 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxObject swig_types[104]
2571 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2573 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2576 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2578 #define SWIGTYPE_p_wxPoint swig_types[112]
2579 #define SWIGTYPE_p_wxPowerEvent swig_types[113]
2580 #define SWIGTYPE_p_wxProcessEvent swig_types[114]
2581 #define SWIGTYPE_p_wxPyApp swig_types[115]
2582 #define SWIGTYPE_p_wxPyArtProvider swig_types[116]
2583 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[117]
2584 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
2585 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[119]
2586 #define SWIGTYPE_p_wxPyDropSource swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropTarget swig_types[121]
2588 #define SWIGTYPE_p_wxPyEvent swig_types[122]
2589 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyImageHandler swig_types[124]
2591 #define SWIGTYPE_p_wxPyLog swig_types[125]
2592 #define SWIGTYPE_p_wxPyProcess swig_types[126]
2593 #define SWIGTYPE_p_wxPySizer swig_types[127]
2594 #define SWIGTYPE_p_wxPyTextDataObject swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[129]
2596 #define SWIGTYPE_p_wxPyTimer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTipProvider swig_types[131]
2598 #define SWIGTYPE_p_wxPyValidator swig_types[132]
2599 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[133]
2600 #define SWIGTYPE_p_wxRect swig_types[134]
2601 #define SWIGTYPE_p_wxScrollEvent swig_types[135]
2602 #define SWIGTYPE_p_wxScrollWinEvent swig_types[136]
2603 #define SWIGTYPE_p_wxSetCursorEvent swig_types[137]
2604 #define SWIGTYPE_p_wxShowEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[139]
2606 #define SWIGTYPE_p_wxSize swig_types[140]
2607 #define SWIGTYPE_p_wxSizeEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSizer swig_types[142]
2609 #define SWIGTYPE_p_wxSizerItem swig_types[143]
2610 #define SWIGTYPE_p_wxSound swig_types[144]
2611 #define SWIGTYPE_p_wxStandardPaths swig_types[145]
2612 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[146]
2613 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStopWatch swig_types[148]
2615 #define SWIGTYPE_p_wxString swig_types[149]
2616 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[150]
2617 #define SWIGTYPE_p_wxSystemOptions swig_types[151]
2618 #define SWIGTYPE_p_wxSystemSettings swig_types[152]
2619 #define SWIGTYPE_p_wxTIFFHandler swig_types[153]
2620 #define SWIGTYPE_p_wxTextCtrl swig_types[154]
2621 #define SWIGTYPE_p_wxTextDataObject swig_types[155]
2622 #define SWIGTYPE_p_wxTimeSpan swig_types[156]
2623 #define SWIGTYPE_p_wxTimer swig_types[157]
2624 #define SWIGTYPE_p_wxTimerEvent swig_types[158]
2625 #define SWIGTYPE_p_wxTimerRunner swig_types[159]
2626 #define SWIGTYPE_p_wxTipProvider swig_types[160]
2627 #define SWIGTYPE_p_wxToolTip swig_types[161]
2628 #define SWIGTYPE_p_wxURLDataObject swig_types[162]
2629 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[163]
2630 #define SWIGTYPE_p_wxValidator swig_types[164]
2631 #define SWIGTYPE_p_wxVideoMode swig_types[165]
2632 #define SWIGTYPE_p_wxWindow swig_types[166]
2633 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[167]
2634 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDisabler swig_types[169]
2636 #define SWIGTYPE_p_wxXPMHandler swig_types[170]
2637 static swig_type_info *swig_types[172];
2638 static swig_module_info swig_module = {swig_types, 171, 0, 0, 0, 0};
2639 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2640 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2641
2642 /* -------- TYPES TABLE (END) -------- */
2643
2644 #if (PY_VERSION_HEX <= 0x02000000)
2645 # if !defined(SWIG_PYTHON_CLASSIC)
2646 # error "This python version requires to use swig with the '-classic' option"
2647 # endif
2648 #endif
2649 #if (PY_VERSION_HEX <= 0x02020000)
2650 # error "This python version requires to use swig with the '-nomodern' option"
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodernargs' option"
2654 #endif
2655 #ifndef METH_O
2656 # error "This python version requires to use swig with the '-nofastunpack' option"
2657 #endif
2658
2659 /*-----------------------------------------------
2660 @(target):= _misc_.so
2661 ------------------------------------------------*/
2662 #define SWIG_init init_misc_
2663
2664 #define SWIG_name "_misc_"
2665
2666 #define SWIGVERSION 0x010329
2667
2668
2669 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2670 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2671
2672
2673 #include <stdexcept>
2674
2675
2676 namespace swig {
2677 class PyObject_ptr {
2678 protected:
2679 PyObject *_obj;
2680
2681 public:
2682 PyObject_ptr() :_obj(0)
2683 {
2684 }
2685
2686 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2687 {
2688 Py_XINCREF(_obj);
2689 }
2690
2691 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2692 {
2693 if (initial_ref) Py_XINCREF(_obj);
2694 }
2695
2696 PyObject_ptr & operator=(const PyObject_ptr& item)
2697 {
2698 Py_XINCREF(item._obj);
2699 Py_XDECREF(_obj);
2700 _obj = item._obj;
2701 return *this;
2702 }
2703
2704 ~PyObject_ptr()
2705 {
2706 Py_XDECREF(_obj);
2707 }
2708
2709 operator PyObject *() const
2710 {
2711 return _obj;
2712 }
2713
2714 PyObject *operator->() const
2715 {
2716 return _obj;
2717 }
2718 };
2719 }
2720
2721
2722 namespace swig {
2723 struct PyObject_var : PyObject_ptr {
2724 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2725
2726 PyObject_var & operator = (PyObject* obj)
2727 {
2728 Py_XDECREF(_obj);
2729 _obj = obj;
2730 return *this;
2731 }
2732 };
2733 }
2734
2735
2736 #include "wx/wxPython/wxPython.h"
2737 #include "wx/wxPython/pyclasses.h"
2738 #include "wx/wxPython/pyistream.h"
2739
2740 static const wxString wxPyEmptyString(wxEmptyString);
2741
2742
2743
2744 #define SWIG_From_long PyInt_FromLong
2745
2746
2747 SWIGINTERNINLINE PyObject *
2748 SWIG_From_int (int value)
2749 {
2750 return SWIG_From_long (value);
2751 }
2752
2753
2754 #include <limits.h>
2755 #ifndef LLONG_MIN
2756 # define LLONG_MIN LONG_LONG_MIN
2757 #endif
2758 #ifndef LLONG_MAX
2759 # define LLONG_MAX LONG_LONG_MAX
2760 #endif
2761 #ifndef ULLONG_MAX
2762 # define ULLONG_MAX ULONG_LONG_MAX
2763 #endif
2764
2765
2766 SWIGINTERN int
2767 SWIG_AsVal_long (PyObject* obj, long* val)
2768 {
2769 if (PyNumber_Check(obj)) {
2770 if (val) *val = PyInt_AsLong(obj);
2771 return SWIG_OK;
2772 }
2773 return SWIG_TypeError;
2774 }
2775
2776
2777 SWIGINTERN int
2778 SWIG_AsVal_int (PyObject * obj, int *val)
2779 {
2780 long v;
2781 int res = SWIG_AsVal_long (obj, &v);
2782 if (SWIG_IsOK(res)) {
2783 if ((v < INT_MIN || v > INT_MAX)) {
2784 return SWIG_OverflowError;
2785 } else {
2786 if (val) *val = static_cast< int >(v);
2787 }
2788 }
2789 return res;
2790 }
2791
2792 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2793
2794 #include <wx/stockitem.h>
2795
2796 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2797 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2798 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2799
2800 SWIGINTERN int
2801 SWIG_AsVal_bool (PyObject *obj, bool *val)
2802 {
2803 if (obj == Py_True) {
2804 if (val) *val = true;
2805 return SWIG_OK;
2806 } else if (obj == Py_False) {
2807 if (val) *val = false;
2808 return SWIG_OK;
2809 } else {
2810 long v = 0;
2811 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2812 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2813 return res;
2814 }
2815 }
2816
2817
2818 wxMemorySize wxGetFreeMemory()
2819 { wxPyRaiseNotImplemented(); return 0; }
2820
2821
2822 SWIGINTERN int
2823 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2824 {
2825 long v = 0;
2826 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2827 return SWIG_TypeError;
2828 }
2829 else if (val)
2830 *val = (unsigned long)v;
2831 return SWIG_OK;
2832 }
2833
2834
2835 SWIGINTERNINLINE PyObject*
2836 SWIG_From_unsigned_SS_long (unsigned long value)
2837 {
2838 return (value > LONG_MAX) ?
2839 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2840 }
2841
2842
2843 void* wxGetXDisplay()
2844 {
2845 #ifdef __WXGTK__
2846 return wxGetDisplay();
2847 #else
2848 return NULL;
2849 #endif
2850 }
2851
2852
2853 wxWindow* FindWindowAtPointer() {
2854 wxPoint unused;
2855 return wxFindWindowAtPointer(unused);
2856 }
2857
2858
2859 void wxWakeUpMainThread() {}
2860
2861
2862 bool wxThread_IsMain() {
2863 #ifdef WXP_WITH_THREAD
2864 return wxThread::IsMain();
2865 #else
2866 return true;
2867 #endif
2868 }
2869
2870 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2871 delete self;
2872 }
2873
2874 #include <wx/snglinst.h>
2875
2876
2877 #ifdef __WXMSW__
2878 #include <wx/msw/private.h>
2879 #include <wx/dynload.h>
2880 #endif
2881
2882
2883
2884 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2885 #if 0
2886 , int method
2887 #endif
2888 )
2889 {
2890 #ifdef __WXMSW__
2891 #if 0
2892 switch (method)
2893 {
2894 case 1:
2895 // This one only partially works. Appears to be an undocumented
2896 // "standard" convention that not all widgets adhear to. For
2897 // example, for some widgets backgrounds or non-client areas may
2898 // not be painted.
2899 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2900 break;
2901
2902 case 2:
2903 #endif
2904 // This one works much better, nearly all widgets and their
2905 // children are captured correctly[**]. Prior to the big
2906 // background erase changes that Vadim did in 2004-2005 this
2907 // method failed badly on XP with Themes activated, most native
2908 // widgets draw only partially, if at all. Without themes it
2909 // worked just like on Win2k. After those changes this method
2910 // works very well.
2911 //
2912 // ** For example the radio buttons in a wxRadioBox are not its
2913 // children by default, but you can capture it via the panel
2914 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2915 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2916 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2917 PRF_ERASEBKGND | PRF_OWNED );
2918 return true;
2919 #if 0
2920 break;
2921
2922 case 3:
2923 // This one is only defined in the latest SDK and is only
2924 // available on XP. MSDN says it is similar to sending WM_PRINT
2925 // so I expect that it will work similar to the above. Since it
2926 // is avaialble only on XP, it can't be compiled like this and
2927 // will have to be loaded dynamically.
2928 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2929
2930 // fall through
2931
2932 case 4:
2933 // Use PrintWindow if available, or fallback to WM_PRINT
2934 // otherwise. Unfortunately using PrintWindow is even worse than
2935 // WM_PRINT. For most native widgets nothing is drawn to the dc
2936 // at all, with or without Themes.
2937 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2938 static bool s_triedToLoad = false;
2939 static PrintWindow_t pfnPrintWindow = NULL;
2940 if ( !s_triedToLoad )
2941 {
2942
2943 s_triedToLoad = true;
2944 wxDynamicLibrary dllUser32(_T("user32.dll"));
2945 if ( dllUser32.IsLoaded() )
2946 {
2947 wxLogNull nolog; // Don't report errors here
2948 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2949 }
2950 }
2951 if (pfnPrintWindow)
2952 {
2953 //printf("Using PrintWindow\n");
2954 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2955 }
2956 else
2957 {
2958 //printf("Using WM_PRINT\n");
2959 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2960 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2961 PRF_ERASEBKGND | PRF_OWNED );
2962 }
2963 }
2964 #endif // 0
2965 #else
2966 return false;
2967 #endif // __WXMSW__
2968 }
2969
2970
2971
2972 #include <wx/tipdlg.h>
2973
2974
2975 SWIGINTERNINLINE PyObject *
2976 SWIG_From_size_t (size_t value)
2977 {
2978 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2979 }
2980
2981
2982 class wxPyTipProvider : public wxTipProvider {
2983 public:
2984 wxPyTipProvider(size_t currentTip)
2985 : wxTipProvider(currentTip) {}
2986
2987 DEC_PYCALLBACK_STRING__pure(GetTip);
2988 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2989 PYPRIVATE;
2990 };
2991
2992 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2993 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2994
2995
2996 SWIGINTERNINLINE int
2997 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2998 {
2999 unsigned long v;
3000 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3001 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3002 return res;
3003 }
3004
3005
3006 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3007
3008 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3009
3010 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3011 : wxTimer(owner, id)
3012 {
3013 if (owner == NULL)
3014 SetOwner(this);
3015 }
3016
3017
3018 SWIGINTERN swig_type_info*
3019 SWIG_pchar_descriptor()
3020 {
3021 static int init = 0;
3022 static swig_type_info* info = 0;
3023 if (!init) {
3024 info = SWIG_TypeQuery("_p_char");
3025 init = 1;
3026 }
3027 return info;
3028 }
3029
3030
3031 SWIGINTERNINLINE PyObject *
3032 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3033 {
3034 if (carray) {
3035 if (size > INT_MAX) {
3036 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3037 return pchar_descriptor ?
3038 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3039 } else {
3040 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3041 }
3042 } else {
3043 return SWIG_Py_Void();
3044 }
3045 }
3046
3047
3048 SWIGINTERNINLINE PyObject *
3049 SWIG_FromCharPtr(const char *cptr)
3050 {
3051 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3052 }
3053
3054
3055 SWIGINTERN int
3056 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3057 {
3058 unsigned long v;
3059 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3060 if (SWIG_IsOK(res)) {
3061 if ((v > UINT_MAX)) {
3062 return SWIG_OverflowError;
3063 } else {
3064 if (val) *val = static_cast< unsigned int >(v);
3065 }
3066 }
3067 return res;
3068 }
3069
3070 SWIGINTERN wxString wxLog_TimeStamp(){
3071 wxString msg;
3072 wxLog::TimeStamp(&msg);
3073 return msg;
3074 }
3075 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3076 // Make some wrappers that double any % signs so they are 'escaped'
3077 void wxPyLogFatalError(const wxString& msg)
3078 {
3079 wxString m(msg);
3080 m.Replace(wxT("%"), wxT("%%"));
3081 wxLogFatalError(m);
3082 }
3083
3084 void wxPyLogError(const wxString& msg)
3085 {
3086 wxString m(msg);
3087 m.Replace(wxT("%"), wxT("%%"));
3088 wxLogError(m);
3089 }
3090
3091 void wxPyLogWarning(const wxString& msg)
3092 {
3093 wxString m(msg);
3094 m.Replace(wxT("%"), wxT("%%"));
3095 wxLogWarning(m);
3096 }
3097
3098 void wxPyLogMessage(const wxString& msg)
3099 {
3100 wxString m(msg);
3101 m.Replace(wxT("%"), wxT("%%"));
3102 wxLogMessage(m);
3103 }
3104
3105 void wxPyLogInfo(const wxString& msg)
3106 {
3107 wxString m(msg);
3108 m.Replace(wxT("%"), wxT("%%"));
3109 wxLogInfo(m);
3110 }
3111
3112 void wxPyLogDebug(const wxString& msg)
3113 {
3114 wxString m(msg);
3115 m.Replace(wxT("%"), wxT("%%"));
3116 wxLogDebug(m);
3117 }
3118
3119 void wxPyLogVerbose(const wxString& msg)
3120 {
3121 wxString m(msg);
3122 m.Replace(wxT("%"), wxT("%%"));
3123 wxLogVerbose(m);
3124 }
3125
3126 void wxPyLogStatus(const wxString& msg)
3127 {
3128 wxString m(msg);
3129 m.Replace(wxT("%"), wxT("%%"));
3130 wxLogStatus(m);
3131 }
3132
3133 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3134 {
3135 wxString m(msg);
3136 m.Replace(wxT("%"), wxT("%%"));
3137 wxLogStatus(pFrame, m);
3138 }
3139
3140 void wxPyLogSysError(const wxString& msg)
3141 {
3142 wxString m(msg);
3143 m.Replace(wxT("%"), wxT("%%"));
3144 wxLogSysError(m);
3145 }
3146
3147 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3148 {
3149 wxString m(msg);
3150 m.Replace(wxT("%"), wxT("%%"));
3151 wxLogGeneric(level, m);
3152 }
3153
3154 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3155 {
3156 wxString m(msg);
3157 m.Replace(wxT("%"), wxT("%%"));
3158 wxLogTrace(mask, m);
3159 }
3160
3161 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3162 {
3163 wxString m(msg);
3164 m.Replace(wxT("%"), wxT("%%"));
3165 wxLogTrace(mask, m);
3166 }
3167
3168
3169
3170 // A wxLog class that can be derived from in wxPython
3171 class wxPyLog : public wxLog {
3172 public:
3173 wxPyLog() : wxLog() {}
3174
3175 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3176 bool found;
3177 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3178 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3179 PyObject* s = wx2PyString(szString);
3180 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3181 Py_DECREF(s);
3182 }
3183 wxPyEndBlockThreads(blocked);
3184 if (! found)
3185 wxLog::DoLog(level, szString, t);
3186 }
3187
3188 virtual void DoLogString(const wxChar *szString, time_t t) {
3189 bool found;
3190 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3191 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3192 PyObject* s = wx2PyString(szString);
3193 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3194 Py_DECREF(s);
3195 }
3196 wxPyEndBlockThreads(blocked);
3197 if (! found)
3198 wxLog::DoLogString(szString, t);
3199 }
3200
3201 DEC_PYCALLBACK_VOID_(Flush);
3202 PYPRIVATE;
3203 };
3204 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3205
3206
3207
3208
3209 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3210
3211
3212 #include <wx/joystick.h>
3213
3214
3215 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3216 // A C++ stub class for wxJoystick for platforms that don't have it.
3217 class wxJoystick : public wxObject {
3218 public:
3219 wxJoystick(int joystick = wxJOYSTICK1) {
3220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3221 PyErr_SetString(PyExc_NotImplementedError,
3222 "wxJoystick is not available on this platform.");
3223 wxPyEndBlockThreads(blocked);
3224 }
3225 wxPoint GetPosition() { return wxPoint(-1,-1); }
3226 int GetZPosition() { return -1; }
3227 int GetButtonState() { return -1; }
3228 int GetPOVPosition() { return -1; }
3229 int GetPOVCTSPosition() { return -1; }
3230 int GetRudderPosition() { return -1; }
3231 int GetUPosition() { return -1; }
3232 int GetVPosition() { return -1; }
3233 int GetMovementThreshold() { return -1; }
3234 void SetMovementThreshold(int threshold) {}
3235
3236 bool IsOk(void) { return false; }
3237 int GetNumberJoysticks() { return -1; }
3238 int GetManufacturerId() { return -1; }
3239 int GetProductId() { return -1; }
3240 wxString GetProductName() { return wxEmptyString; }
3241 int GetXMin() { return -1; }
3242 int GetYMin() { return -1; }
3243 int GetZMin() { return -1; }
3244 int GetXMax() { return -1; }
3245 int GetYMax() { return -1; }
3246 int GetZMax() { return -1; }
3247 int GetNumberButtons() { return -1; }
3248 int GetNumberAxes() { return -1; }
3249 int GetMaxButtons() { return -1; }
3250 int GetMaxAxes() { return -1; }
3251 int GetPollingMin() { return -1; }
3252 int GetPollingMax() { return -1; }
3253 int GetRudderMin() { return -1; }
3254 int GetRudderMax() { return -1; }
3255 int GetUMin() { return -1; }
3256 int GetUMax() { return -1; }
3257 int GetVMin() { return -1; }
3258 int GetVMax() { return -1; }
3259
3260 bool HasRudder() { return false; }
3261 bool HasZ() { return false; }
3262 bool HasU() { return false; }
3263 bool HasV() { return false; }
3264 bool HasPOV() { return false; }
3265 bool HasPOV4Dir() { return false; }
3266 bool HasPOVCTS() { return false; }
3267
3268 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3269 bool ReleaseCapture() { return false; }
3270 };
3271 #endif
3272
3273
3274 #include <wx/sound.h>
3275
3276
3277 #if !wxUSE_SOUND
3278 // A C++ stub class for wxWave for platforms that don't have it.
3279 class wxSound : public wxObject
3280 {
3281 public:
3282 wxSound() {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288 wxSound(const wxString&/*, bool*/) {
3289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3290 PyErr_SetString(PyExc_NotImplementedError,
3291 "wxSound is not available on this platform.");
3292 wxPyEndBlockThreads(blocked);
3293 }
3294 wxSound(int, const wxByte*) {
3295 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3296 PyErr_SetString(PyExc_NotImplementedError,
3297 "wxSound is not available on this platform.");
3298 wxPyEndBlockThreads(blocked);
3299 }
3300
3301 ~wxSound() {};
3302
3303 bool Create(const wxString&/*, bool*/) { return false; }
3304 bool Create(int, const wxByte*) { return false; };
3305 bool IsOk() { return false; };
3306 bool Play(unsigned) const { return false; }
3307 static bool Play(const wxString&, unsigned) { return false; }
3308 static void Stop() {}
3309 };
3310
3311 #endif
3312
3313 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3314 if (fileName.Length() == 0)
3315 return new wxSound;
3316 else
3317 return new wxSound(fileName);
3318 }
3319 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3320 unsigned char* buffer; int size;
3321 wxSound *sound = NULL;
3322
3323 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3324 if (!PyArg_Parse(data, "t#", &buffer, &size))
3325 goto done;
3326 sound = new wxSound(size, buffer);
3327 done:
3328 wxPyEndBlockThreads(blocked);
3329 return sound;
3330 }
3331 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3332 #ifndef __WXMAC__
3333 unsigned char* buffer;
3334 int size;
3335 bool rv = false;
3336
3337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3338 if (!PyArg_Parse(data, "t#", &buffer, &size))
3339 goto done;
3340 rv = self->Create(size, buffer);
3341 done:
3342 wxPyEndBlockThreads(blocked);
3343 return rv;
3344 #else
3345 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3346 PyErr_SetString(PyExc_NotImplementedError,
3347 "Create from data is not available on this platform.");
3348 wxPyEndBlockThreads(blocked);
3349 return false;
3350 #endif
3351 }
3352
3353 #include <wx/mimetype.h>
3354
3355 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3356 wxString str;
3357 if (self->GetMimeType(&str))
3358 return wx2PyString(str);
3359 else
3360 RETURN_NONE();
3361 }
3362 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3363 wxArrayString arr;
3364 if (self->GetMimeTypes(arr))
3365 return wxArrayString2PyList_helper(arr);
3366 else
3367 RETURN_NONE();
3368 }
3369 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3370 wxArrayString arr;
3371 if (self->GetExtensions(arr))
3372 return wxArrayString2PyList_helper(arr);
3373 else
3374 RETURN_NONE();
3375 }
3376 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3377 wxIconLocation loc;
3378 if (self->GetIcon(&loc))
3379 return new wxIcon(loc);
3380 else
3381 return NULL;
3382 }
3383 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3384 wxIconLocation loc;
3385 if (self->GetIcon(&loc)) {
3386 wxString iconFile = loc.GetFileName();
3387 int iconIndex = -1;
3388
3389
3390
3391 // Make a tuple and put the values in it
3392 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3393 PyObject* tuple = PyTuple_New(3);
3394 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3395 wxT("wxIcon"), true));
3396 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3397 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3398 wxPyEndBlockThreads(blocked);
3399 return tuple;
3400 }
3401 else
3402 RETURN_NONE();
3403 }
3404 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3405 wxString str;
3406 if (self->GetDescription(&str))
3407 return wx2PyString(str);
3408 else
3409 RETURN_NONE();
3410 }
3411 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3412 wxString str;
3413 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3414 return wx2PyString(str);
3415 else
3416 RETURN_NONE();
3417 }
3418 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3419 wxString str;
3420 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3421 return wx2PyString(str);
3422 else
3423 RETURN_NONE();
3424 }
3425 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3426 wxArrayString verbs;
3427 wxArrayString commands;
3428 if (self->GetAllCommands(&verbs, &commands,
3429 wxFileType::MessageParameters(filename, mimetype))) {
3430 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3431 PyObject* tuple = PyTuple_New(2);
3432 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3433 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3434 wxPyEndBlockThreads(blocked);
3435 return tuple;
3436 }
3437 else
3438 RETURN_NONE();
3439 }
3440 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3441 return wxFileType::ExpandCommand(command,
3442 wxFileType::MessageParameters(filename, mimetype));
3443 }
3444 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3445 wxArrayString arr;
3446 self->EnumAllFileTypes(arr);
3447 return wxArrayString2PyList_helper(arr);
3448 }
3449
3450 #include <wx/artprov.h>
3451
3452 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3453 static const wxString wxPyART_MENU(wxART_MENU);
3454 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3455 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3456 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3457 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3458 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3459 static const wxString wxPyART_OTHER(wxART_OTHER);
3460 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3461 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3462 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3463 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3464 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3465 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3466 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3467 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3468 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3469 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3470 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3471 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3472 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3473 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3474 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3475 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3476 static const wxString wxPyART_PRINT(wxART_PRINT);
3477 static const wxString wxPyART_HELP(wxART_HELP);
3478 static const wxString wxPyART_TIP(wxART_TIP);
3479 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3480 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3481 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3482 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3483 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3484 static const wxString wxPyART_CDROM(wxART_CDROM);
3485 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3486 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3487 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3488 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3489 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3490 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3491 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3492 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3493 static const wxString wxPyART_ERROR(wxART_ERROR);
3494 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3495 static const wxString wxPyART_WARNING(wxART_WARNING);
3496 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3497 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3498 static const wxString wxPyART_COPY(wxART_COPY);
3499 static const wxString wxPyART_CUT(wxART_CUT);
3500 static const wxString wxPyART_PASTE(wxART_PASTE);
3501 static const wxString wxPyART_DELETE(wxART_DELETE);
3502 static const wxString wxPyART_NEW(wxART_NEW);
3503 static const wxString wxPyART_UNDO(wxART_UNDO);
3504 static const wxString wxPyART_REDO(wxART_REDO);
3505 static const wxString wxPyART_QUIT(wxART_QUIT);
3506 static const wxString wxPyART_FIND(wxART_FIND);
3507 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3508 // Python aware wxArtProvider
3509 class wxPyArtProvider : public wxArtProvider {
3510 public:
3511
3512 virtual wxBitmap CreateBitmap(const wxArtID& id,
3513 const wxArtClient& client,
3514 const wxSize& size) {
3515 wxBitmap rval = wxNullBitmap;
3516 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3517 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3518 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3519 PyObject* ro;
3520 wxBitmap* ptr;
3521 PyObject* s1, *s2;
3522 s1 = wx2PyString(id);
3523 s2 = wx2PyString(client);
3524 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3525 Py_DECREF(so);
3526 Py_DECREF(s1);
3527 Py_DECREF(s2);
3528 if (ro) {
3529 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3530 rval = *ptr;
3531 Py_DECREF(ro);
3532 }
3533 }
3534 wxPyEndBlockThreads(blocked);
3535 return rval;
3536 }
3537
3538 PYPRIVATE;
3539 };
3540
3541 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3542
3543
3544
3545 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3546 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3547 PyObject* ret = PyTuple_New(3);
3548 if (ret) {
3549 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3550 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3551 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3552 }
3553 wxPyEndBlockThreads(blocked);
3554 return ret;
3555 }
3556
3557 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3558 bool cont;
3559 long index = 0;
3560 wxString value;
3561
3562 cont = self->GetFirstGroup(value, index);
3563 return __EnumerationHelper(cont, value, index);
3564 }
3565 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3566 bool cont;
3567 wxString value;
3568
3569 cont = self->GetNextGroup(value, index);
3570 return __EnumerationHelper(cont, value, index);
3571 }
3572 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3573 bool cont;
3574 long index = 0;
3575 wxString value;
3576
3577 cont = self->GetFirstEntry(value, index);
3578 return __EnumerationHelper(cont, value, index);
3579 }
3580 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3581 bool cont;
3582 wxString value;
3583
3584 cont = self->GetNextEntry(value, index);
3585 return __EnumerationHelper(cont, value, index);
3586 }
3587 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3588 long rv;
3589 self->Read(key, &rv, defaultVal);
3590 return rv;
3591 }
3592
3593 SWIGINTERN int
3594 SWIG_AsVal_double (PyObject *obj, double* val)
3595 {
3596 if (PyNumber_Check(obj)) {
3597 if (val) *val = PyFloat_AsDouble(obj);
3598 return SWIG_OK;
3599 }
3600 return SWIG_TypeError;
3601 }
3602
3603 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3604 double rv;
3605 self->Read(key, &rv, defaultVal);
3606 return rv;
3607 }
3608
3609 #define SWIG_From_double PyFloat_FromDouble
3610
3611 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3612 bool rv;
3613 self->Read(key, &rv, defaultVal);
3614 return rv;
3615 }
3616
3617 #include <wx/datetime.h>
3618
3619 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3620 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3621
3622 #define LOCAL_TZ wxDateTime::Local
3623
3624 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3625 wxString am;
3626 wxString pm;
3627 wxDateTime::GetAmPmStrings(&am, &pm);
3628 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3629 PyObject* tup = PyTuple_New(2);
3630 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3631 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3632 wxPyEndBlockThreads(blocked);
3633 return tup;
3634 }
3635
3636 SWIGINTERNINLINE PyObject *
3637 SWIG_From_unsigned_SS_int (unsigned int value)
3638 {
3639 return SWIG_From_unsigned_SS_long (value);
3640 }
3641
3642 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3643 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3644 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3645 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3646 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3647 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3649 return (*self < *other);
3650 }
3651 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3653 return (*self <= *other);
3654 }
3655 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3657 return (*self > *other);
3658 }
3659 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3661 return (*self >= *other);
3662 }
3663 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3664 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3665 return (*self == *other);
3666 }
3667 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3668 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3669 return (*self != *other);
3670 }
3671 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3672 const wxChar* rv;
3673 const wxChar* _date = date;
3674 rv = self->ParseRfc822Date(_date);
3675 if (rv == NULL) return -1;
3676 return rv - _date;
3677 }
3678 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3679 const wxChar* rv;
3680 const wxChar* _date = date;
3681 rv = self->ParseFormat(_date, format, dateDef);
3682 if (rv == NULL) return -1;
3683 return rv - _date;
3684 }
3685 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3686 const wxChar* rv;
3687 const wxChar* _datetime = datetime;
3688 rv = self->ParseDateTime(_datetime);
3689 if (rv == NULL) return -1;
3690 return rv - _datetime;
3691 }
3692 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3693 const wxChar* rv;
3694 const wxChar* _date = date;
3695 rv = self->ParseDate(_date);
3696 if (rv == NULL) return -1;
3697 return rv - _date;
3698 }
3699 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3700 const wxChar* rv;
3701 const wxChar* _time = time;
3702 rv = self->ParseTime(_time);
3703 if (rv == NULL) return -1;
3704 return rv - _time;
3705 }
3706 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3707 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3708 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3710 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3711 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3712 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3713 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3714 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3715 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3716 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3717 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3718 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3719 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3720 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3721 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3722
3723 #include <wx/dataobj.h>
3724
3725 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3726 size_t count = self->GetFormatCount(dir);
3727 wxDataFormat* formats = new wxDataFormat[count];
3728 self->GetAllFormats(formats, dir);
3729
3730 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3731 PyObject* list = PyList_New(count);
3732 for (size_t i=0; i<count; i++) {
3733 wxDataFormat* format = new wxDataFormat(formats[i]);
3734 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3735 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3736 }
3737 wxPyEndBlockThreads(blocked);
3738 delete [] formats;
3739 return list;
3740 }
3741 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3742 PyObject* rval = NULL;
3743 size_t size = self->GetDataSize(format);
3744 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3745 if (size) {
3746 char* buf = new char[size];
3747 if (self->GetDataHere(format, buf))
3748 rval = PyString_FromStringAndSize(buf, size);
3749 delete [] buf;
3750 }
3751 if (! rval) {
3752 rval = Py_None;
3753 Py_INCREF(rval);
3754 }
3755 wxPyEndBlockThreads(blocked);
3756 return rval;
3757 }
3758 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3759 bool rval;
3760 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3761 if (PyString_Check(data)) {
3762 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3763 }
3764 else {
3765 // raise a TypeError if not a string
3766 PyErr_SetString(PyExc_TypeError, "String expected.");
3767 rval = false;
3768 }
3769 wxPyEndBlockThreads(blocked);
3770 return rval;
3771 }
3772 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3773 PyObject* rval = NULL;
3774 size_t size = self->GetDataSize();
3775 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3776 if (size) {
3777 char* buf = new char[size];
3778 if (self->GetDataHere(buf))
3779 rval = PyString_FromStringAndSize(buf, size);
3780 delete [] buf;
3781 }
3782 if (! rval) {
3783 rval = Py_None;
3784 Py_INCREF(rval);
3785 }
3786 wxPyEndBlockThreads(blocked);
3787 return rval;
3788 }
3789 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3790 bool rval;
3791 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3792 if (PyString_Check(data)) {
3793 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3794 }
3795 else {
3796 // raise a TypeError if not a string
3797 PyErr_SetString(PyExc_TypeError, "String expected.");
3798 rval = false;
3799 }
3800 wxPyEndBlockThreads(blocked);
3801 return rval;
3802 }
3803 // Create a new class for wxPython to use
3804 class wxPyDataObjectSimple : public wxDataObjectSimple {
3805 public:
3806 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3807 : wxDataObjectSimple(format) {}
3808
3809 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3810 bool GetDataHere(void *buf) const;
3811 bool SetData(size_t len, const void *buf) const;
3812 PYPRIVATE;
3813 };
3814
3815 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3816
3817 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3818 // We need to get the data for this object and write it to buf. I think
3819 // the best way to do this for wxPython is to have the Python method
3820 // return either a string or None and then act appropriately with the
3821 // C++ version.
3822
3823 bool rval = false;
3824 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3825 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3826 PyObject* ro;
3827 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3828 if (ro) {
3829 rval = (ro != Py_None && PyString_Check(ro));
3830 if (rval)
3831 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3832 Py_DECREF(ro);
3833 }
3834 }
3835 wxPyEndBlockThreads(blocked);
3836 return rval;
3837 }
3838
3839 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3840 // For this one we simply need to make a string from buf and len
3841 // and send it to the Python method.
3842 bool rval = false;
3843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3844 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3845 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3846 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3847 Py_DECREF(data);
3848 }
3849 wxPyEndBlockThreads(blocked);
3850 return rval;
3851 }
3852
3853 // Create a new class for wxPython to use
3854 class wxPyTextDataObject : public wxTextDataObject {
3855 public:
3856 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3857 : wxTextDataObject(text) {}
3858
3859 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3860 DEC_PYCALLBACK_STRING__const(GetText);
3861 DEC_PYCALLBACK__STRING(SetText);
3862 PYPRIVATE;
3863 };
3864
3865 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3866 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3867 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3868
3869
3870 // Create a new class for wxPython to use
3871 class wxPyBitmapDataObject : public wxBitmapDataObject {
3872 public:
3873 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3874 : wxBitmapDataObject(bitmap) {}
3875
3876 wxBitmap GetBitmap() const;
3877 void SetBitmap(const wxBitmap& bitmap);
3878 PYPRIVATE;
3879 };
3880
3881 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3882 wxBitmap* rval = &wxNullBitmap;
3883 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3884 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3885 PyObject* ro;
3886 wxBitmap* ptr;
3887 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3888 if (ro) {
3889 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3890 rval = ptr;
3891 Py_DECREF(ro);
3892 }
3893 }
3894 wxPyEndBlockThreads(blocked);
3895 return *rval;
3896 }
3897
3898 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3899 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3900 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3901 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3902 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3903 Py_DECREF(bo);
3904 }
3905 wxPyEndBlockThreads(blocked);
3906 }
3907
3908 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3909 return new wxCustomDataObject(wxDataFormat(formatName));
3910 }
3911 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3912 bool rval;
3913 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3914 if (PyString_Check(data)) {
3915 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3916 }
3917 else {
3918 // raise a TypeError if not a string
3919 PyErr_SetString(PyExc_TypeError, "String expected.");
3920 rval = false;
3921 }
3922 wxPyEndBlockThreads(blocked);
3923 return rval;
3924 }
3925 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3926 PyObject* obj;
3927 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3928 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3929 wxPyEndBlockThreads(blocked);
3930 return obj;
3931 }
3932
3933 class wxMetafileDataObject : public wxDataObjectSimple
3934 {
3935 public:
3936 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3937 };
3938
3939
3940 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3941
3942
3943 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3944 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3945 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3946 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3947 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3948
3949
3950 class wxPyTextDropTarget : public wxTextDropTarget {
3951 public:
3952 wxPyTextDropTarget() {}
3953
3954 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3955
3956 DEC_PYCALLBACK__(OnLeave);
3957 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3959 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3960 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3961
3962 PYPRIVATE;
3963 };
3964
3965 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3966 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3967 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3969 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3970 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3971
3972
3973
3974 class wxPyFileDropTarget : public wxFileDropTarget {
3975 public:
3976 wxPyFileDropTarget() {}
3977
3978 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3979
3980 DEC_PYCALLBACK__(OnLeave);
3981 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3983 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3984 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3985
3986 PYPRIVATE;
3987 };
3988
3989 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3990 const wxArrayString& filenames) {
3991 bool rval = false;
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3994 PyObject* list = wxArrayString2PyList_helper(filenames);
3995 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3996 Py_DECREF(list);
3997 }
3998 wxPyEndBlockThreads(blocked);
3999 return rval;
4000 }
4001
4002
4003
4004 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4005 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4008 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4009
4010
4011
4012
4013 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4014
4015 #include <wx/display.h>
4016
4017 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4018 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4019
4020 #if !wxUSE_DISPLAY
4021 const wxVideoMode wxDefaultVideoMode;
4022 #endif
4023
4024 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4025 #if wxUSE_DISPLAY
4026 PyObject* pyList = NULL;
4027 wxArrayVideoModes arr = self->GetModes(mode);
4028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4029 pyList = PyList_New(0);
4030 for (size_t i=0; i < arr.GetCount(); i++)
4031 {
4032 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4033 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4034 PyList_Append(pyList, pyObj);
4035 Py_DECREF(pyObj);
4036 }
4037 wxPyEndBlockThreads(blocked);
4038 return pyList;
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return NULL;
4042 #endif
4043 }
4044 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4045 #if wxUSE_DISPLAY
4046 return self->GetCurrentMode();
4047 #else
4048 wxPyRaiseNotImplemented();
4049 return wxDefaultVideoMode;
4050 #endif
4051 }
4052 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4053 #if wxUSE_DISPLAY
4054 return self->ChangeMode(mode);
4055 #else
4056 wxPyRaiseNotImplemented();
4057 return false;
4058 #endif
4059 }
4060 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4061 #if wxUSE_DISPLAY
4062 self->ResetMode();
4063 #else
4064 wxPyRaiseNotImplemented();
4065 #endif
4066 }
4067
4068 #include <wx/stdpaths.h>
4069
4070 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4071 return (wxStandardPaths*) &wxStandardPaths::Get();
4072 }
4073
4074 #ifndef wxHAS_POWER_EVENTS
4075 // Dummy class and other definitions for platforms that don't have them
4076
4077 // See wxPython_int.h for wxPowerEvent
4078
4079 enum {
4080 wxEVT_POWER_SUSPENDING,
4081 wxEVT_POWER_SUSPENDED,
4082 wxEVT_POWER_SUSPEND_CANCEL,
4083 wxEVT_POWER_RESUME,
4084 };
4085
4086 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4087 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4088
4089 #endif
4090
4091 #ifdef __cplusplus
4092 extern "C" {
4093 #endif
4094 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4095 PyObject *resultobj = 0;
4096 wxSystemColour arg1 ;
4097 wxColour result;
4098 int val1 ;
4099 int ecode1 = 0 ;
4100 PyObject * obj0 = 0 ;
4101 char * kwnames[] = {
4102 (char *) "index", NULL
4103 };
4104
4105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4106 ecode1 = SWIG_AsVal_int(obj0, &val1);
4107 if (!SWIG_IsOK(ecode1)) {
4108 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4109 }
4110 arg1 = static_cast< wxSystemColour >(val1);
4111 {
4112 if (!wxPyCheckForApp()) SWIG_fail;
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 result = wxSystemSettings::GetColour(arg1);
4115 wxPyEndAllowThreads(__tstate);
4116 if (PyErr_Occurred()) SWIG_fail;
4117 }
4118 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4119 return resultobj;
4120 fail:
4121 return NULL;
4122 }
4123
4124
4125 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4126 PyObject *resultobj = 0;
4127 wxSystemFont arg1 ;
4128 wxFont result;
4129 int val1 ;
4130 int ecode1 = 0 ;
4131 PyObject * obj0 = 0 ;
4132 char * kwnames[] = {
4133 (char *) "index", NULL
4134 };
4135
4136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4137 ecode1 = SWIG_AsVal_int(obj0, &val1);
4138 if (!SWIG_IsOK(ecode1)) {
4139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4140 }
4141 arg1 = static_cast< wxSystemFont >(val1);
4142 {
4143 if (!wxPyCheckForApp()) SWIG_fail;
4144 PyThreadState* __tstate = wxPyBeginAllowThreads();
4145 result = wxSystemSettings::GetFont(arg1);
4146 wxPyEndAllowThreads(__tstate);
4147 if (PyErr_Occurred()) SWIG_fail;
4148 }
4149 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4150 return resultobj;
4151 fail:
4152 return NULL;
4153 }
4154
4155
4156 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4157 PyObject *resultobj = 0;
4158 wxSystemMetric arg1 ;
4159 wxWindow *arg2 = (wxWindow *) NULL ;
4160 int result;
4161 int val1 ;
4162 int ecode1 = 0 ;
4163 void *argp2 = 0 ;
4164 int res2 = 0 ;
4165 PyObject * obj0 = 0 ;
4166 PyObject * obj1 = 0 ;
4167 char * kwnames[] = {
4168 (char *) "index",(char *) "win", NULL
4169 };
4170
4171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4172 ecode1 = SWIG_AsVal_int(obj0, &val1);
4173 if (!SWIG_IsOK(ecode1)) {
4174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4175 }
4176 arg1 = static_cast< wxSystemMetric >(val1);
4177 if (obj1) {
4178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4179 if (!SWIG_IsOK(res2)) {
4180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4181 }
4182 arg2 = reinterpret_cast< wxWindow * >(argp2);
4183 }
4184 {
4185 if (!wxPyCheckForApp()) SWIG_fail;
4186 PyThreadState* __tstate = wxPyBeginAllowThreads();
4187 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4188 wxPyEndAllowThreads(__tstate);
4189 if (PyErr_Occurred()) SWIG_fail;
4190 }
4191 resultobj = SWIG_From_int(static_cast< int >(result));
4192 return resultobj;
4193 fail:
4194 return NULL;
4195 }
4196
4197
4198 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4199 PyObject *resultobj = 0;
4200 wxSystemFeature arg1 ;
4201 bool result;
4202 int val1 ;
4203 int ecode1 = 0 ;
4204 PyObject * obj0 = 0 ;
4205 char * kwnames[] = {
4206 (char *) "index", NULL
4207 };
4208
4209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4210 ecode1 = SWIG_AsVal_int(obj0, &val1);
4211 if (!SWIG_IsOK(ecode1)) {
4212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4213 }
4214 arg1 = static_cast< wxSystemFeature >(val1);
4215 {
4216 if (!wxPyCheckForApp()) SWIG_fail;
4217 PyThreadState* __tstate = wxPyBeginAllowThreads();
4218 result = (bool)wxSystemSettings::HasFeature(arg1);
4219 wxPyEndAllowThreads(__tstate);
4220 if (PyErr_Occurred()) SWIG_fail;
4221 }
4222 {
4223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4224 }
4225 return resultobj;
4226 fail:
4227 return NULL;
4228 }
4229
4230
4231 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4232 PyObject *resultobj = 0;
4233 wxSystemScreenType result;
4234
4235 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4236 {
4237 if (!wxPyCheckForApp()) SWIG_fail;
4238 PyThreadState* __tstate = wxPyBeginAllowThreads();
4239 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4240 wxPyEndAllowThreads(__tstate);
4241 if (PyErr_Occurred()) SWIG_fail;
4242 }
4243 resultobj = SWIG_From_int(static_cast< int >(result));
4244 return resultobj;
4245 fail:
4246 return NULL;
4247 }
4248
4249
4250 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4251 PyObject *resultobj = 0;
4252 wxSystemScreenType arg1 ;
4253 int val1 ;
4254 int ecode1 = 0 ;
4255 PyObject * obj0 = 0 ;
4256 char * kwnames[] = {
4257 (char *) "screen", NULL
4258 };
4259
4260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4261 ecode1 = SWIG_AsVal_int(obj0, &val1);
4262 if (!SWIG_IsOK(ecode1)) {
4263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4264 }
4265 arg1 = static_cast< wxSystemScreenType >(val1);
4266 {
4267 if (!wxPyCheckForApp()) SWIG_fail;
4268 PyThreadState* __tstate = wxPyBeginAllowThreads();
4269 wxSystemSettings::SetScreenType(arg1);
4270 wxPyEndAllowThreads(__tstate);
4271 if (PyErr_Occurred()) SWIG_fail;
4272 }
4273 resultobj = SWIG_Py_Void();
4274 return resultobj;
4275 fail:
4276 return NULL;
4277 }
4278
4279
4280 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4281 PyObject *obj;
4282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4283 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4284 return SWIG_Py_Void();
4285 }
4286
4287 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4288 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4289 return 1;
4290 }
4291
4292
4293 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4294 PyObject *pyobj = 0;
4295
4296 {
4297 #if wxUSE_UNICODE
4298 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4299 #else
4300 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4301 #endif
4302 }
4303 return pyobj;
4304 }
4305
4306
4307 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4308 PyObject *resultobj = 0;
4309 wxSystemOptions *result = 0 ;
4310
4311 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4312 {
4313 PyThreadState* __tstate = wxPyBeginAllowThreads();
4314 result = (wxSystemOptions *)new wxSystemOptions();
4315 wxPyEndAllowThreads(__tstate);
4316 if (PyErr_Occurred()) SWIG_fail;
4317 }
4318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4319 return resultobj;
4320 fail:
4321 return NULL;
4322 }
4323
4324
4325 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4326 PyObject *resultobj = 0;
4327 wxString *arg1 = 0 ;
4328 wxString *arg2 = 0 ;
4329 bool temp1 = false ;
4330 bool temp2 = false ;
4331 PyObject * obj0 = 0 ;
4332 PyObject * obj1 = 0 ;
4333 char * kwnames[] = {
4334 (char *) "name",(char *) "value", NULL
4335 };
4336
4337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4338 {
4339 arg1 = wxString_in_helper(obj0);
4340 if (arg1 == NULL) SWIG_fail;
4341 temp1 = true;
4342 }
4343 {
4344 arg2 = wxString_in_helper(obj1);
4345 if (arg2 == NULL) SWIG_fail;
4346 temp2 = true;
4347 }
4348 {
4349 PyThreadState* __tstate = wxPyBeginAllowThreads();
4350 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4351 wxPyEndAllowThreads(__tstate);
4352 if (PyErr_Occurred()) SWIG_fail;
4353 }
4354 resultobj = SWIG_Py_Void();
4355 {
4356 if (temp1)
4357 delete arg1;
4358 }
4359 {
4360 if (temp2)
4361 delete arg2;
4362 }
4363 return resultobj;
4364 fail:
4365 {
4366 if (temp1)
4367 delete arg1;
4368 }
4369 {
4370 if (temp2)
4371 delete arg2;
4372 }
4373 return NULL;
4374 }
4375
4376
4377 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4378 PyObject *resultobj = 0;
4379 wxString *arg1 = 0 ;
4380 int arg2 ;
4381 bool temp1 = false ;
4382 int val2 ;
4383 int ecode2 = 0 ;
4384 PyObject * obj0 = 0 ;
4385 PyObject * obj1 = 0 ;
4386 char * kwnames[] = {
4387 (char *) "name",(char *) "value", NULL
4388 };
4389
4390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4391 {
4392 arg1 = wxString_in_helper(obj0);
4393 if (arg1 == NULL) SWIG_fail;
4394 temp1 = true;
4395 }
4396 ecode2 = SWIG_AsVal_int(obj1, &val2);
4397 if (!SWIG_IsOK(ecode2)) {
4398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4399 }
4400 arg2 = static_cast< int >(val2);
4401 {
4402 PyThreadState* __tstate = wxPyBeginAllowThreads();
4403 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4404 wxPyEndAllowThreads(__tstate);
4405 if (PyErr_Occurred()) SWIG_fail;
4406 }
4407 resultobj = SWIG_Py_Void();
4408 {
4409 if (temp1)
4410 delete arg1;
4411 }
4412 return resultobj;
4413 fail:
4414 {
4415 if (temp1)
4416 delete arg1;
4417 }
4418 return NULL;
4419 }
4420
4421
4422 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4423 PyObject *resultobj = 0;
4424 wxString *arg1 = 0 ;
4425 wxString result;
4426 bool temp1 = false ;
4427 PyObject * obj0 = 0 ;
4428 char * kwnames[] = {
4429 (char *) "name", NULL
4430 };
4431
4432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4433 {
4434 arg1 = wxString_in_helper(obj0);
4435 if (arg1 == NULL) SWIG_fail;
4436 temp1 = true;
4437 }
4438 {
4439 PyThreadState* __tstate = wxPyBeginAllowThreads();
4440 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4441 wxPyEndAllowThreads(__tstate);
4442 if (PyErr_Occurred()) SWIG_fail;
4443 }
4444 {
4445 #if wxUSE_UNICODE
4446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4447 #else
4448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4449 #endif
4450 }
4451 {
4452 if (temp1)
4453 delete arg1;
4454 }
4455 return resultobj;
4456 fail:
4457 {
4458 if (temp1)
4459 delete arg1;
4460 }
4461 return NULL;
4462 }
4463
4464
4465 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4466 PyObject *resultobj = 0;
4467 wxString *arg1 = 0 ;
4468 int result;
4469 bool temp1 = false ;
4470 PyObject * obj0 = 0 ;
4471 char * kwnames[] = {
4472 (char *) "name", NULL
4473 };
4474
4475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4476 {
4477 arg1 = wxString_in_helper(obj0);
4478 if (arg1 == NULL) SWIG_fail;
4479 temp1 = true;
4480 }
4481 {
4482 PyThreadState* __tstate = wxPyBeginAllowThreads();
4483 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4484 wxPyEndAllowThreads(__tstate);
4485 if (PyErr_Occurred()) SWIG_fail;
4486 }
4487 resultobj = SWIG_From_int(static_cast< int >(result));
4488 {
4489 if (temp1)
4490 delete arg1;
4491 }
4492 return resultobj;
4493 fail:
4494 {
4495 if (temp1)
4496 delete arg1;
4497 }
4498 return NULL;
4499 }
4500
4501
4502 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4503 PyObject *resultobj = 0;
4504 wxString *arg1 = 0 ;
4505 bool result;
4506 bool temp1 = false ;
4507 PyObject * obj0 = 0 ;
4508 char * kwnames[] = {
4509 (char *) "name", NULL
4510 };
4511
4512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4513 {
4514 arg1 = wxString_in_helper(obj0);
4515 if (arg1 == NULL) SWIG_fail;
4516 temp1 = true;
4517 }
4518 {
4519 PyThreadState* __tstate = wxPyBeginAllowThreads();
4520 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4521 wxPyEndAllowThreads(__tstate);
4522 if (PyErr_Occurred()) SWIG_fail;
4523 }
4524 {
4525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4526 }
4527 {
4528 if (temp1)
4529 delete arg1;
4530 }
4531 return resultobj;
4532 fail:
4533 {
4534 if (temp1)
4535 delete arg1;
4536 }
4537 return NULL;
4538 }
4539
4540
4541 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4542 PyObject *resultobj = 0;
4543 wxString *arg1 = 0 ;
4544 bool result;
4545 bool temp1 = false ;
4546 PyObject * obj0 = 0 ;
4547 char * kwnames[] = {
4548 (char *) "name", NULL
4549 };
4550
4551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4552 {
4553 arg1 = wxString_in_helper(obj0);
4554 if (arg1 == NULL) SWIG_fail;
4555 temp1 = true;
4556 }
4557 {
4558 PyThreadState* __tstate = wxPyBeginAllowThreads();
4559 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4560 wxPyEndAllowThreads(__tstate);
4561 if (PyErr_Occurred()) SWIG_fail;
4562 }
4563 {
4564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4565 }
4566 {
4567 if (temp1)
4568 delete arg1;
4569 }
4570 return resultobj;
4571 fail:
4572 {
4573 if (temp1)
4574 delete arg1;
4575 }
4576 return NULL;
4577 }
4578
4579
4580 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4581 PyObject *obj;
4582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4583 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4584 return SWIG_Py_Void();
4585 }
4586
4587 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4588 return SWIG_Python_InitShadowInstance(args);
4589 }
4590
4591 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4592 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4593 return 1;
4594 }
4595
4596
4597 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4598 PyObject *pyobj = 0;
4599
4600 {
4601 #if wxUSE_UNICODE
4602 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4603 #else
4604 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4605 #endif
4606 }
4607 return pyobj;
4608 }
4609
4610
4611 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4612 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4613 return 1;
4614 }
4615
4616
4617 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4618 PyObject *pyobj = 0;
4619
4620 {
4621 #if wxUSE_UNICODE
4622 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4623 #else
4624 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4625 #endif
4626 }
4627 return pyobj;
4628 }
4629
4630
4631 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4632 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4633 return 1;
4634 }
4635
4636
4637 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4638 PyObject *pyobj = 0;
4639
4640 {
4641 #if wxUSE_UNICODE
4642 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4643 #else
4644 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4645 #endif
4646 }
4647 return pyobj;
4648 }
4649
4650
4651 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4652 PyObject *resultobj = 0;
4653 long result;
4654
4655 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4656 {
4657 PyThreadState* __tstate = wxPyBeginAllowThreads();
4658 result = (long)wxNewId();
4659 wxPyEndAllowThreads(__tstate);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 resultobj = SWIG_From_long(static_cast< long >(result));
4663 return resultobj;
4664 fail:
4665 return NULL;
4666 }
4667
4668
4669 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4670 PyObject *resultobj = 0;
4671 long arg1 ;
4672 long val1 ;
4673 int ecode1 = 0 ;
4674 PyObject * obj0 = 0 ;
4675 char * kwnames[] = {
4676 (char *) "id", NULL
4677 };
4678
4679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4680 ecode1 = SWIG_AsVal_long(obj0, &val1);
4681 if (!SWIG_IsOK(ecode1)) {
4682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4683 }
4684 arg1 = static_cast< long >(val1);
4685 {
4686 PyThreadState* __tstate = wxPyBeginAllowThreads();
4687 wxRegisterId(arg1);
4688 wxPyEndAllowThreads(__tstate);
4689 if (PyErr_Occurred()) SWIG_fail;
4690 }
4691 resultobj = SWIG_Py_Void();
4692 return resultobj;
4693 fail:
4694 return NULL;
4695 }
4696
4697
4698 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4699 PyObject *resultobj = 0;
4700 long result;
4701
4702 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4703 {
4704 PyThreadState* __tstate = wxPyBeginAllowThreads();
4705 result = (long)wxGetCurrentId();
4706 wxPyEndAllowThreads(__tstate);
4707 if (PyErr_Occurred()) SWIG_fail;
4708 }
4709 resultobj = SWIG_From_long(static_cast< long >(result));
4710 return resultobj;
4711 fail:
4712 return NULL;
4713 }
4714
4715
4716 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4717 PyObject *resultobj = 0;
4718 int arg1 ;
4719 bool result;
4720 int val1 ;
4721 int ecode1 = 0 ;
4722 PyObject * obj0 = 0 ;
4723 char * kwnames[] = {
4724 (char *) "id", NULL
4725 };
4726
4727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4728 ecode1 = SWIG_AsVal_int(obj0, &val1);
4729 if (!SWIG_IsOK(ecode1)) {
4730 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4731 }
4732 arg1 = static_cast< int >(val1);
4733 {
4734 PyThreadState* __tstate = wxPyBeginAllowThreads();
4735 result = (bool)wxIsStockID(arg1);
4736 wxPyEndAllowThreads(__tstate);
4737 if (PyErr_Occurred()) SWIG_fail;
4738 }
4739 {
4740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4741 }
4742 return resultobj;
4743 fail:
4744 return NULL;
4745 }
4746
4747
4748 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4749 PyObject *resultobj = 0;
4750 int arg1 ;
4751 wxString *arg2 = 0 ;
4752 bool result;
4753 int val1 ;
4754 int ecode1 = 0 ;
4755 bool temp2 = false ;
4756 PyObject * obj0 = 0 ;
4757 PyObject * obj1 = 0 ;
4758 char * kwnames[] = {
4759 (char *) "id",(char *) "label", NULL
4760 };
4761
4762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4763 ecode1 = SWIG_AsVal_int(obj0, &val1);
4764 if (!SWIG_IsOK(ecode1)) {
4765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4766 }
4767 arg1 = static_cast< int >(val1);
4768 {
4769 arg2 = wxString_in_helper(obj1);
4770 if (arg2 == NULL) SWIG_fail;
4771 temp2 = true;
4772 }
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4776 wxPyEndAllowThreads(__tstate);
4777 if (PyErr_Occurred()) SWIG_fail;
4778 }
4779 {
4780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4781 }
4782 {
4783 if (temp2)
4784 delete arg2;
4785 }
4786 return resultobj;
4787 fail:
4788 {
4789 if (temp2)
4790 delete arg2;
4791 }
4792 return NULL;
4793 }
4794
4795
4796 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4797 PyObject *resultobj = 0;
4798 int arg1 ;
4799 bool arg2 = (bool) true ;
4800 wxString arg3 = (wxString) wxPyEmptyString ;
4801 wxString result;
4802 int val1 ;
4803 int ecode1 = 0 ;
4804 bool val2 ;
4805 int ecode2 = 0 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 PyObject * obj2 = 0 ;
4809 char * kwnames[] = {
4810 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4811 };
4812
4813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4814 ecode1 = SWIG_AsVal_int(obj0, &val1);
4815 if (!SWIG_IsOK(ecode1)) {
4816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4817 }
4818 arg1 = static_cast< int >(val1);
4819 if (obj1) {
4820 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4821 if (!SWIG_IsOK(ecode2)) {
4822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4823 }
4824 arg2 = static_cast< bool >(val2);
4825 }
4826 if (obj2) {
4827 {
4828 wxString* sptr = wxString_in_helper(obj2);
4829 if (sptr == NULL) SWIG_fail;
4830 arg3 = *sptr;
4831 delete sptr;
4832 }
4833 }
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 result = wxGetStockLabel(arg1,arg2,arg3);
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 {
4841 #if wxUSE_UNICODE
4842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4843 #else
4844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4845 #endif
4846 }
4847 return resultobj;
4848 fail:
4849 return NULL;
4850 }
4851
4852
4853 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4854 PyObject *resultobj = 0;
4855
4856 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4857 {
4858 if (!wxPyCheckForApp()) SWIG_fail;
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 wxBell();
4861 wxPyEndAllowThreads(__tstate);
4862 if (PyErr_Occurred()) SWIG_fail;
4863 }
4864 resultobj = SWIG_Py_Void();
4865 return resultobj;
4866 fail:
4867 return NULL;
4868 }
4869
4870
4871 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4872 PyObject *resultobj = 0;
4873
4874 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4875 {
4876 if (!wxPyCheckForApp()) SWIG_fail;
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 wxEndBusyCursor();
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 resultobj = SWIG_Py_Void();
4883 return resultobj;
4884 fail:
4885 return NULL;
4886 }
4887
4888
4889 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4890 PyObject *resultobj = 0;
4891 bool arg1 = (bool) true ;
4892 long result;
4893 bool val1 ;
4894 int ecode1 = 0 ;
4895 PyObject * obj0 = 0 ;
4896 char * kwnames[] = {
4897 (char *) "resetTimer", NULL
4898 };
4899
4900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4901 if (obj0) {
4902 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4903 if (!SWIG_IsOK(ecode1)) {
4904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4905 }
4906 arg1 = static_cast< bool >(val1);
4907 }
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 result = (long)wxGetElapsedTime(arg1);
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = SWIG_From_long(static_cast< long >(result));
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4922 PyObject *resultobj = 0;
4923 bool result;
4924
4925 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4926 {
4927 PyThreadState* __tstate = wxPyBeginAllowThreads();
4928 result = (bool)wxIsBusy();
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 {
4933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4934 }
4935 return resultobj;
4936 fail:
4937 return NULL;
4938 }
4939
4940
4941 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4942 PyObject *resultobj = 0;
4943 wxString result;
4944
4945 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 result = wxNow();
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 {
4953 #if wxUSE_UNICODE
4954 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4955 #else
4956 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4957 #endif
4958 }
4959 return resultobj;
4960 fail:
4961 return NULL;
4962 }
4963
4964
4965 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj = 0;
4967 wxString const &arg1_defvalue = wxPyEmptyString ;
4968 wxString *arg1 = (wxString *) &arg1_defvalue ;
4969 bool result;
4970 bool temp1 = false ;
4971 PyObject * obj0 = 0 ;
4972 char * kwnames[] = {
4973 (char *) "command", NULL
4974 };
4975
4976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4977 if (obj0) {
4978 {
4979 arg1 = wxString_in_helper(obj0);
4980 if (arg1 == NULL) SWIG_fail;
4981 temp1 = true;
4982 }
4983 }
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (bool)wxShell((wxString const &)*arg1);
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 {
4991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4992 }
4993 {
4994 if (temp1)
4995 delete arg1;
4996 }
4997 return resultobj;
4998 fail:
4999 {
5000 if (temp1)
5001 delete arg1;
5002 }
5003 return NULL;
5004 }
5005
5006
5007 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5008 PyObject *resultobj = 0;
5009
5010 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 wxStartTimer();
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 resultobj = SWIG_Py_Void();
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025 PyObject *resultobj = 0;
5026 int *arg1 = (int *) 0 ;
5027 int *arg2 = (int *) 0 ;
5028 int result;
5029 int temp1 ;
5030 int res1 = SWIG_TMPOBJ ;
5031 int temp2 ;
5032 int res2 = SWIG_TMPOBJ ;
5033
5034 arg1 = &temp1;
5035 arg2 = &temp2;
5036 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5037 {
5038 PyThreadState* __tstate = wxPyBeginAllowThreads();
5039 result = (int)wxGetOsVersion(arg1,arg2);
5040 wxPyEndAllowThreads(__tstate);
5041 if (PyErr_Occurred()) SWIG_fail;
5042 }
5043 resultobj = SWIG_From_int(static_cast< int >(result));
5044 if (SWIG_IsTmpObj(res1)) {
5045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5046 } else {
5047 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5049 }
5050 if (SWIG_IsTmpObj(res2)) {
5051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5052 } else {
5053 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5055 }
5056 return resultobj;
5057 fail:
5058 return NULL;
5059 }
5060
5061
5062 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5063 PyObject *resultobj = 0;
5064 wxString result;
5065
5066 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = wxGetOsDescription();
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 {
5074 #if wxUSE_UNICODE
5075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5076 #else
5077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5078 #endif
5079 }
5080 return resultobj;
5081 fail:
5082 return NULL;
5083 }
5084
5085
5086 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5087 PyObject *resultobj = 0;
5088 wxMemorySize result;
5089
5090 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5091 {
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 result = wxGetFreeMemory();
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5098 return resultobj;
5099 fail:
5100 return NULL;
5101 }
5102
5103
5104 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5105 PyObject *resultobj = 0;
5106 wxShutdownFlags arg1 ;
5107 bool result;
5108 int val1 ;
5109 int ecode1 = 0 ;
5110 PyObject * obj0 = 0 ;
5111 char * kwnames[] = {
5112 (char *) "wFlags", NULL
5113 };
5114
5115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5116 ecode1 = SWIG_AsVal_int(obj0, &val1);
5117 if (!SWIG_IsOK(ecode1)) {
5118 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5119 }
5120 arg1 = static_cast< wxShutdownFlags >(val1);
5121 {
5122 if (!wxPyCheckForApp()) SWIG_fail;
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 result = (bool)wxShutdown(arg1);
5125 wxPyEndAllowThreads(__tstate);
5126 if (PyErr_Occurred()) SWIG_fail;
5127 }
5128 {
5129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5130 }
5131 return resultobj;
5132 fail:
5133 return NULL;
5134 }
5135
5136
5137 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5138 PyObject *resultobj = 0;
5139 int arg1 ;
5140 int val1 ;
5141 int ecode1 = 0 ;
5142 PyObject * obj0 = 0 ;
5143 char * kwnames[] = {
5144 (char *) "secs", NULL
5145 };
5146
5147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5148 ecode1 = SWIG_AsVal_int(obj0, &val1);
5149 if (!SWIG_IsOK(ecode1)) {
5150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5151 }
5152 arg1 = static_cast< int >(val1);
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 wxSleep(arg1);
5156 wxPyEndAllowThreads(__tstate);
5157 if (PyErr_Occurred()) SWIG_fail;
5158 }
5159 resultobj = SWIG_Py_Void();
5160 return resultobj;
5161 fail:
5162 return NULL;
5163 }
5164
5165
5166 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5167 PyObject *resultobj = 0;
5168 unsigned long arg1 ;
5169 unsigned long val1 ;
5170 int ecode1 = 0 ;
5171 PyObject * obj0 = 0 ;
5172 char * kwnames[] = {
5173 (char *) "milliseconds", NULL
5174 };
5175
5176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5177 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5178 if (!SWIG_IsOK(ecode1)) {
5179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5180 }
5181 arg1 = static_cast< unsigned long >(val1);
5182 {
5183 PyThreadState* __tstate = wxPyBeginAllowThreads();
5184 wxMilliSleep(arg1);
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 resultobj = SWIG_Py_Void();
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5196 PyObject *resultobj = 0;
5197 unsigned long arg1 ;
5198 unsigned long val1 ;
5199 int ecode1 = 0 ;
5200 PyObject * obj0 = 0 ;
5201 char * kwnames[] = {
5202 (char *) "microseconds", NULL
5203 };
5204
5205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5206 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5207 if (!SWIG_IsOK(ecode1)) {
5208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5209 }
5210 arg1 = static_cast< unsigned long >(val1);
5211 {
5212 PyThreadState* __tstate = wxPyBeginAllowThreads();
5213 wxMicroSleep(arg1);
5214 wxPyEndAllowThreads(__tstate);
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 resultobj = SWIG_Py_Void();
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5225 PyObject *resultobj = 0;
5226 bool arg1 ;
5227 bool val1 ;
5228 int ecode1 = 0 ;
5229 PyObject * obj0 = 0 ;
5230 char * kwnames[] = {
5231 (char *) "enable", NULL
5232 };
5233
5234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5235 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5236 if (!SWIG_IsOK(ecode1)) {
5237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5238 }
5239 arg1 = static_cast< bool >(val1);
5240 {
5241 PyThreadState* __tstate = wxPyBeginAllowThreads();
5242 wxEnableTopLevelWindows(arg1);
5243 wxPyEndAllowThreads(__tstate);
5244 if (PyErr_Occurred()) SWIG_fail;
5245 }
5246 resultobj = SWIG_Py_Void();
5247 return resultobj;
5248 fail:
5249 return NULL;
5250 }
5251
5252
5253 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5254 PyObject *resultobj = 0;
5255 wxString *arg1 = 0 ;
5256 wxString result;
5257 bool temp1 = false ;
5258 PyObject * obj0 = 0 ;
5259 char * kwnames[] = {
5260 (char *) "in", NULL
5261 };
5262
5263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5264 {
5265 arg1 = wxString_in_helper(obj0);
5266 if (arg1 == NULL) SWIG_fail;
5267 temp1 = true;
5268 }
5269 {
5270 PyThreadState* __tstate = wxPyBeginAllowThreads();
5271 result = wxStripMenuCodes((wxString const &)*arg1);
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 {
5276 #if wxUSE_UNICODE
5277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5278 #else
5279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5280 #endif
5281 }
5282 {
5283 if (temp1)
5284 delete arg1;
5285 }
5286 return resultobj;
5287 fail:
5288 {
5289 if (temp1)
5290 delete arg1;
5291 }
5292 return NULL;
5293 }
5294
5295
5296 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5297 PyObject *resultobj = 0;
5298 wxString result;
5299
5300 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5301 {
5302 PyThreadState* __tstate = wxPyBeginAllowThreads();
5303 result = wxGetEmailAddress();
5304 wxPyEndAllowThreads(__tstate);
5305 if (PyErr_Occurred()) SWIG_fail;
5306 }
5307 {
5308 #if wxUSE_UNICODE
5309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5310 #else
5311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5312 #endif
5313 }
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5321 PyObject *resultobj = 0;
5322 wxString result;
5323
5324 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5325 {
5326 PyThreadState* __tstate = wxPyBeginAllowThreads();
5327 result = wxGetHostName();
5328 wxPyEndAllowThreads(__tstate);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 {
5332 #if wxUSE_UNICODE
5333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5334 #else
5335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5336 #endif
5337 }
5338 return resultobj;
5339 fail:
5340 return NULL;
5341 }
5342
5343
5344 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5345 PyObject *resultobj = 0;
5346 wxString result;
5347
5348 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5349 {
5350 PyThreadState* __tstate = wxPyBeginAllowThreads();
5351 result = wxGetFullHostName();
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 {
5356 #if wxUSE_UNICODE
5357 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5358 #else
5359 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5360 #endif
5361 }
5362 return resultobj;
5363 fail:
5364 return NULL;
5365 }
5366
5367
5368 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5369 PyObject *resultobj = 0;
5370 wxString result;
5371
5372 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5373 {
5374 PyThreadState* __tstate = wxPyBeginAllowThreads();
5375 result = wxGetUserId();
5376 wxPyEndAllowThreads(__tstate);
5377 if (PyErr_Occurred()) SWIG_fail;
5378 }
5379 {
5380 #if wxUSE_UNICODE
5381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5382 #else
5383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5384 #endif
5385 }
5386 return resultobj;
5387 fail:
5388 return NULL;
5389 }
5390
5391
5392 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5393 PyObject *resultobj = 0;
5394 wxString result;
5395
5396 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = wxGetUserName();
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 {
5404 #if wxUSE_UNICODE
5405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5406 #else
5407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5408 #endif
5409 }
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *resultobj = 0;
5418 wxString result;
5419
5420 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5421 {
5422 PyThreadState* __tstate = wxPyBeginAllowThreads();
5423 result = wxGetHomeDir();
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 {
5428 #if wxUSE_UNICODE
5429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5430 #else
5431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5432 #endif
5433 }
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5441 PyObject *resultobj = 0;
5442 wxString const &arg1_defvalue = wxPyEmptyString ;
5443 wxString *arg1 = (wxString *) &arg1_defvalue ;
5444 wxString result;
5445 bool temp1 = false ;
5446 PyObject * obj0 = 0 ;
5447 char * kwnames[] = {
5448 (char *) "user", NULL
5449 };
5450
5451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5452 if (obj0) {
5453 {
5454 arg1 = wxString_in_helper(obj0);
5455 if (arg1 == NULL) SWIG_fail;
5456 temp1 = true;
5457 }
5458 }
5459 {
5460 PyThreadState* __tstate = wxPyBeginAllowThreads();
5461 result = wxGetUserHome((wxString const &)*arg1);
5462 wxPyEndAllowThreads(__tstate);
5463 if (PyErr_Occurred()) SWIG_fail;
5464 }
5465 {
5466 #if wxUSE_UNICODE
5467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5468 #else
5469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5470 #endif
5471 }
5472 {
5473 if (temp1)
5474 delete arg1;
5475 }
5476 return resultobj;
5477 fail:
5478 {
5479 if (temp1)
5480 delete arg1;
5481 }
5482 return NULL;
5483 }
5484
5485
5486 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5487 PyObject *resultobj = 0;
5488 unsigned long result;
5489
5490 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5491 {
5492 PyThreadState* __tstate = wxPyBeginAllowThreads();
5493 result = (unsigned long)wxGetProcessId();
5494 wxPyEndAllowThreads(__tstate);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5505 PyObject *resultobj = 0;
5506
5507 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5508 {
5509 PyThreadState* __tstate = wxPyBeginAllowThreads();
5510 wxTrap();
5511 wxPyEndAllowThreads(__tstate);
5512 if (PyErr_Occurred()) SWIG_fail;
5513 }
5514 resultobj = SWIG_Py_Void();
5515 return resultobj;
5516 fail:
5517 return NULL;
5518 }
5519
5520
5521 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5522 PyObject *resultobj = 0;
5523 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5524 wxString *arg1 = (wxString *) &arg1_defvalue ;
5525 wxString const &arg2_defvalue = wxPyEmptyString ;
5526 wxString *arg2 = (wxString *) &arg2_defvalue ;
5527 wxString const &arg3_defvalue = wxPyEmptyString ;
5528 wxString *arg3 = (wxString *) &arg3_defvalue ;
5529 wxString const &arg4_defvalue = wxPyEmptyString ;
5530 wxString *arg4 = (wxString *) &arg4_defvalue ;
5531 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5532 wxString *arg5 = (wxString *) &arg5_defvalue ;
5533 int arg6 = (int) 0 ;
5534 wxWindow *arg7 = (wxWindow *) NULL ;
5535 int arg8 = (int) -1 ;
5536 int arg9 = (int) -1 ;
5537 wxString result;
5538 bool temp1 = false ;
5539 bool temp2 = false ;
5540 bool temp3 = false ;
5541 bool temp4 = false ;
5542 bool temp5 = false ;
5543 int val6 ;
5544 int ecode6 = 0 ;
5545 void *argp7 = 0 ;
5546 int res7 = 0 ;
5547 int val8 ;
5548 int ecode8 = 0 ;
5549 int val9 ;
5550 int ecode9 = 0 ;
5551 PyObject * obj0 = 0 ;
5552 PyObject * obj1 = 0 ;
5553 PyObject * obj2 = 0 ;
5554 PyObject * obj3 = 0 ;
5555 PyObject * obj4 = 0 ;
5556 PyObject * obj5 = 0 ;
5557 PyObject * obj6 = 0 ;
5558 PyObject * obj7 = 0 ;
5559 PyObject * obj8 = 0 ;
5560 char * kwnames[] = {
5561 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5562 };
5563
5564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5565 if (obj0) {
5566 {
5567 arg1 = wxString_in_helper(obj0);
5568 if (arg1 == NULL) SWIG_fail;
5569 temp1 = true;
5570 }
5571 }
5572 if (obj1) {
5573 {
5574 arg2 = wxString_in_helper(obj1);
5575 if (arg2 == NULL) SWIG_fail;
5576 temp2 = true;
5577 }
5578 }
5579 if (obj2) {
5580 {
5581 arg3 = wxString_in_helper(obj2);
5582 if (arg3 == NULL) SWIG_fail;
5583 temp3 = true;
5584 }
5585 }
5586 if (obj3) {
5587 {
5588 arg4 = wxString_in_helper(obj3);
5589 if (arg4 == NULL) SWIG_fail;
5590 temp4 = true;
5591 }
5592 }
5593 if (obj4) {
5594 {
5595 arg5 = wxString_in_helper(obj4);
5596 if (arg5 == NULL) SWIG_fail;
5597 temp5 = true;
5598 }
5599 }
5600 if (obj5) {
5601 ecode6 = SWIG_AsVal_int(obj5, &val6);
5602 if (!SWIG_IsOK(ecode6)) {
5603 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5604 }
5605 arg6 = static_cast< int >(val6);
5606 }
5607 if (obj6) {
5608 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5609 if (!SWIG_IsOK(res7)) {
5610 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5611 }
5612 arg7 = reinterpret_cast< wxWindow * >(argp7);
5613 }
5614 if (obj7) {
5615 ecode8 = SWIG_AsVal_int(obj7, &val8);
5616 if (!SWIG_IsOK(ecode8)) {
5617 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5618 }
5619 arg8 = static_cast< int >(val8);
5620 }
5621 if (obj8) {
5622 ecode9 = SWIG_AsVal_int(obj8, &val9);
5623 if (!SWIG_IsOK(ecode9)) {
5624 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5625 }
5626 arg9 = static_cast< int >(val9);
5627 }
5628 {
5629 if (!wxPyCheckForApp()) SWIG_fail;
5630 PyThreadState* __tstate = wxPyBeginAllowThreads();
5631 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5632 wxPyEndAllowThreads(__tstate);
5633 if (PyErr_Occurred()) SWIG_fail;
5634 }
5635 {
5636 #if wxUSE_UNICODE
5637 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5638 #else
5639 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5640 #endif
5641 }
5642 {
5643 if (temp1)
5644 delete arg1;
5645 }
5646 {
5647 if (temp2)
5648 delete arg2;
5649 }
5650 {
5651 if (temp3)
5652 delete arg3;
5653 }
5654 {
5655 if (temp4)
5656 delete arg4;
5657 }
5658 {
5659 if (temp5)
5660 delete arg5;
5661 }
5662 return resultobj;
5663 fail:
5664 {
5665 if (temp1)
5666 delete arg1;
5667 }
5668 {
5669 if (temp2)
5670 delete arg2;
5671 }
5672 {
5673 if (temp3)
5674 delete arg3;
5675 }
5676 {
5677 if (temp4)
5678 delete arg4;
5679 }
5680 {
5681 if (temp5)
5682 delete arg5;
5683 }
5684 return NULL;
5685 }
5686
5687
5688 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5689 PyObject *resultobj = 0;
5690 wxString *arg1 = 0 ;
5691 wxString *arg2 = 0 ;
5692 wxString const &arg3_defvalue = wxPyEmptyString ;
5693 wxString *arg3 = (wxString *) &arg3_defvalue ;
5694 wxWindow *arg4 = (wxWindow *) NULL ;
5695 wxString result;
5696 bool temp1 = false ;
5697 bool temp2 = false ;
5698 bool temp3 = false ;
5699 void *argp4 = 0 ;
5700 int res4 = 0 ;
5701 PyObject * obj0 = 0 ;
5702 PyObject * obj1 = 0 ;
5703 PyObject * obj2 = 0 ;
5704 PyObject * obj3 = 0 ;
5705 char * kwnames[] = {
5706 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5707 };
5708
5709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5710 {
5711 arg1 = wxString_in_helper(obj0);
5712 if (arg1 == NULL) SWIG_fail;
5713 temp1 = true;
5714 }
5715 {
5716 arg2 = wxString_in_helper(obj1);
5717 if (arg2 == NULL) SWIG_fail;
5718 temp2 = true;
5719 }
5720 if (obj2) {
5721 {
5722 arg3 = wxString_in_helper(obj2);
5723 if (arg3 == NULL) SWIG_fail;
5724 temp3 = true;
5725 }
5726 }
5727 if (obj3) {
5728 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5729 if (!SWIG_IsOK(res4)) {
5730 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5731 }
5732 arg4 = reinterpret_cast< wxWindow * >(argp4);
5733 }
5734 {
5735 if (!wxPyCheckForApp()) SWIG_fail;
5736 PyThreadState* __tstate = wxPyBeginAllowThreads();
5737 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5738 wxPyEndAllowThreads(__tstate);
5739 if (PyErr_Occurred()) SWIG_fail;
5740 }
5741 {
5742 #if wxUSE_UNICODE
5743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5744 #else
5745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5746 #endif
5747 }
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 return resultobj;
5761 fail:
5762 {
5763 if (temp1)
5764 delete arg1;
5765 }
5766 {
5767 if (temp2)
5768 delete arg2;
5769 }
5770 {
5771 if (temp3)
5772 delete arg3;
5773 }
5774 return NULL;
5775 }
5776
5777
5778 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5779 PyObject *resultobj = 0;
5780 wxString *arg1 = 0 ;
5781 wxString *arg2 = 0 ;
5782 wxString const &arg3_defvalue = wxPyEmptyString ;
5783 wxString *arg3 = (wxString *) &arg3_defvalue ;
5784 wxWindow *arg4 = (wxWindow *) NULL ;
5785 wxString result;
5786 bool temp1 = false ;
5787 bool temp2 = false ;
5788 bool temp3 = false ;
5789 void *argp4 = 0 ;
5790 int res4 = 0 ;
5791 PyObject * obj0 = 0 ;
5792 PyObject * obj1 = 0 ;
5793 PyObject * obj2 = 0 ;
5794 PyObject * obj3 = 0 ;
5795 char * kwnames[] = {
5796 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5797 };
5798
5799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5800 {
5801 arg1 = wxString_in_helper(obj0);
5802 if (arg1 == NULL) SWIG_fail;
5803 temp1 = true;
5804 }
5805 {
5806 arg2 = wxString_in_helper(obj1);
5807 if (arg2 == NULL) SWIG_fail;
5808 temp2 = true;
5809 }
5810 if (obj2) {
5811 {
5812 arg3 = wxString_in_helper(obj2);
5813 if (arg3 == NULL) SWIG_fail;
5814 temp3 = true;
5815 }
5816 }
5817 if (obj3) {
5818 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5819 if (!SWIG_IsOK(res4)) {
5820 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5821 }
5822 arg4 = reinterpret_cast< wxWindow * >(argp4);
5823 }
5824 {
5825 if (!wxPyCheckForApp()) SWIG_fail;
5826 PyThreadState* __tstate = wxPyBeginAllowThreads();
5827 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5828 wxPyEndAllowThreads(__tstate);
5829 if (PyErr_Occurred()) SWIG_fail;
5830 }
5831 {
5832 #if wxUSE_UNICODE
5833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5834 #else
5835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5836 #endif
5837 }
5838 {
5839 if (temp1)
5840 delete arg1;
5841 }
5842 {
5843 if (temp2)
5844 delete arg2;
5845 }
5846 {
5847 if (temp3)
5848 delete arg3;
5849 }
5850 return resultobj;
5851 fail:
5852 {
5853 if (temp1)
5854 delete arg1;
5855 }
5856 {
5857 if (temp2)
5858 delete arg2;
5859 }
5860 {
5861 if (temp3)
5862 delete arg3;
5863 }
5864 return NULL;
5865 }
5866
5867
5868 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5869 PyObject *resultobj = 0;
5870 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5871 wxString *arg1 = (wxString *) &arg1_defvalue ;
5872 wxString const &arg2_defvalue = wxPyEmptyString ;
5873 wxString *arg2 = (wxString *) &arg2_defvalue ;
5874 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5875 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5876 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5877 wxWindow *arg5 = (wxWindow *) NULL ;
5878 wxString result;
5879 bool temp1 = false ;
5880 bool temp2 = false ;
5881 long val3 ;
5882 int ecode3 = 0 ;
5883 wxPoint temp4 ;
5884 void *argp5 = 0 ;
5885 int res5 = 0 ;
5886 PyObject * obj0 = 0 ;
5887 PyObject * obj1 = 0 ;
5888 PyObject * obj2 = 0 ;
5889 PyObject * obj3 = 0 ;
5890 PyObject * obj4 = 0 ;
5891 char * kwnames[] = {
5892 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5893 };
5894
5895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5896 if (obj0) {
5897 {
5898 arg1 = wxString_in_helper(obj0);
5899 if (arg1 == NULL) SWIG_fail;
5900 temp1 = true;
5901 }
5902 }
5903 if (obj1) {
5904 {
5905 arg2 = wxString_in_helper(obj1);
5906 if (arg2 == NULL) SWIG_fail;
5907 temp2 = true;
5908 }
5909 }
5910 if (obj2) {
5911 ecode3 = SWIG_AsVal_long(obj2, &val3);
5912 if (!SWIG_IsOK(ecode3)) {
5913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5914 }
5915 arg3 = static_cast< long >(val3);
5916 }
5917 if (obj3) {
5918 {
5919 arg4 = &temp4;
5920 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5921 }
5922 }
5923 if (obj4) {
5924 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5925 if (!SWIG_IsOK(res5)) {
5926 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5927 }
5928 arg5 = reinterpret_cast< wxWindow * >(argp5);
5929 }
5930 {
5931 if (!wxPyCheckForApp()) SWIG_fail;
5932 PyThreadState* __tstate = wxPyBeginAllowThreads();
5933 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5934 wxPyEndAllowThreads(__tstate);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 {
5938 #if wxUSE_UNICODE
5939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5940 #else
5941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5942 #endif
5943 }
5944 {
5945 if (temp1)
5946 delete arg1;
5947 }
5948 {
5949 if (temp2)
5950 delete arg2;
5951 }
5952 return resultobj;
5953 fail:
5954 {
5955 if (temp1)
5956 delete arg1;
5957 }
5958 {
5959 if (temp2)
5960 delete arg2;
5961 }
5962 return NULL;
5963 }
5964
5965
5966 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj = 0;
5968 wxString *arg1 = 0 ;
5969 wxString const &arg2_defvalue = wxPyEmptyString ;
5970 wxString *arg2 = (wxString *) &arg2_defvalue ;
5971 wxString const &arg3_defvalue = wxPyEmptyString ;
5972 wxString *arg3 = (wxString *) &arg3_defvalue ;
5973 wxWindow *arg4 = (wxWindow *) NULL ;
5974 int arg5 = (int) -1 ;
5975 int arg6 = (int) -1 ;
5976 bool arg7 = (bool) true ;
5977 wxString result;
5978 bool temp1 = false ;
5979 bool temp2 = false ;
5980 bool temp3 = false ;
5981 void *argp4 = 0 ;
5982 int res4 = 0 ;
5983 int val5 ;
5984 int ecode5 = 0 ;
5985 int val6 ;
5986 int ecode6 = 0 ;
5987 bool val7 ;
5988 int ecode7 = 0 ;
5989 PyObject * obj0 = 0 ;
5990 PyObject * obj1 = 0 ;
5991 PyObject * obj2 = 0 ;
5992 PyObject * obj3 = 0 ;
5993 PyObject * obj4 = 0 ;
5994 PyObject * obj5 = 0 ;
5995 PyObject * obj6 = 0 ;
5996 char * kwnames[] = {
5997 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5998 };
5999
6000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6001 {
6002 arg1 = wxString_in_helper(obj0);
6003 if (arg1 == NULL) SWIG_fail;
6004 temp1 = true;
6005 }
6006 if (obj1) {
6007 {
6008 arg2 = wxString_in_helper(obj1);
6009 if (arg2 == NULL) SWIG_fail;
6010 temp2 = true;
6011 }
6012 }
6013 if (obj2) {
6014 {
6015 arg3 = wxString_in_helper(obj2);
6016 if (arg3 == NULL) SWIG_fail;
6017 temp3 = true;
6018 }
6019 }
6020 if (obj3) {
6021 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6022 if (!SWIG_IsOK(res4)) {
6023 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6024 }
6025 arg4 = reinterpret_cast< wxWindow * >(argp4);
6026 }
6027 if (obj4) {
6028 ecode5 = SWIG_AsVal_int(obj4, &val5);
6029 if (!SWIG_IsOK(ecode5)) {
6030 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6031 }
6032 arg5 = static_cast< int >(val5);
6033 }
6034 if (obj5) {
6035 ecode6 = SWIG_AsVal_int(obj5, &val6);
6036 if (!SWIG_IsOK(ecode6)) {
6037 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6038 }
6039 arg6 = static_cast< int >(val6);
6040 }
6041 if (obj6) {
6042 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6043 if (!SWIG_IsOK(ecode7)) {
6044 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6045 }
6046 arg7 = static_cast< bool >(val7);
6047 }
6048 {
6049 if (!wxPyCheckForApp()) SWIG_fail;
6050 PyThreadState* __tstate = wxPyBeginAllowThreads();
6051 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6052 wxPyEndAllowThreads(__tstate);
6053 if (PyErr_Occurred()) SWIG_fail;
6054 }
6055 {
6056 #if wxUSE_UNICODE
6057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6058 #else
6059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6060 #endif
6061 }
6062 {
6063 if (temp1)
6064 delete arg1;
6065 }
6066 {
6067 if (temp2)
6068 delete arg2;
6069 }
6070 {
6071 if (temp3)
6072 delete arg3;
6073 }
6074 return resultobj;
6075 fail:
6076 {
6077 if (temp1)
6078 delete arg1;
6079 }
6080 {
6081 if (temp2)
6082 delete arg2;
6083 }
6084 {
6085 if (temp3)
6086 delete arg3;
6087 }
6088 return NULL;
6089 }
6090
6091
6092 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6093 PyObject *resultobj = 0;
6094 wxString *arg1 = 0 ;
6095 wxString const &arg2_defvalue = wxPyEmptyString ;
6096 wxString *arg2 = (wxString *) &arg2_defvalue ;
6097 wxString const &arg3_defvalue = wxPyEmptyString ;
6098 wxString *arg3 = (wxString *) &arg3_defvalue ;
6099 wxWindow *arg4 = (wxWindow *) NULL ;
6100 wxString result;
6101 bool temp1 = false ;
6102 bool temp2 = false ;
6103 bool temp3 = false ;
6104 void *argp4 = 0 ;
6105 int res4 = 0 ;
6106 PyObject * obj0 = 0 ;
6107 PyObject * obj1 = 0 ;
6108 PyObject * obj2 = 0 ;
6109 PyObject * obj3 = 0 ;
6110 char * kwnames[] = {
6111 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6112 };
6113
6114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6115 {
6116 arg1 = wxString_in_helper(obj0);
6117 if (arg1 == NULL) SWIG_fail;
6118 temp1 = true;
6119 }
6120 if (obj1) {
6121 {
6122 arg2 = wxString_in_helper(obj1);
6123 if (arg2 == NULL) SWIG_fail;
6124 temp2 = true;
6125 }
6126 }
6127 if (obj2) {
6128 {
6129 arg3 = wxString_in_helper(obj2);
6130 if (arg3 == NULL) SWIG_fail;
6131 temp3 = true;
6132 }
6133 }
6134 if (obj3) {
6135 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6136 if (!SWIG_IsOK(res4)) {
6137 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6138 }
6139 arg4 = reinterpret_cast< wxWindow * >(argp4);
6140 }
6141 {
6142 if (!wxPyCheckForApp()) SWIG_fail;
6143 PyThreadState* __tstate = wxPyBeginAllowThreads();
6144 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6145 wxPyEndAllowThreads(__tstate);
6146 if (PyErr_Occurred()) SWIG_fail;
6147 }
6148 {
6149 #if wxUSE_UNICODE
6150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6151 #else
6152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6153 #endif
6154 }
6155 {
6156 if (temp1)
6157 delete arg1;
6158 }
6159 {
6160 if (temp2)
6161 delete arg2;
6162 }
6163 {
6164 if (temp3)
6165 delete arg3;
6166 }
6167 return resultobj;
6168 fail:
6169 {
6170 if (temp1)
6171 delete arg1;
6172 }
6173 {
6174 if (temp2)
6175 delete arg2;
6176 }
6177 {
6178 if (temp3)
6179 delete arg3;
6180 }
6181 return NULL;
6182 }
6183
6184
6185 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6186 PyObject *resultobj = 0;
6187 wxString *arg1 = 0 ;
6188 wxString *arg2 = 0 ;
6189 int arg3 ;
6190 wxString *arg4 = (wxString *) 0 ;
6191 wxWindow *arg5 = (wxWindow *) NULL ;
6192 int arg6 = (int) -1 ;
6193 int arg7 = (int) -1 ;
6194 bool arg8 = (bool) true ;
6195 int arg9 = (int) 150 ;
6196 int arg10 = (int) 200 ;
6197 wxString result;
6198 bool temp1 = false ;
6199 bool temp2 = false ;
6200 void *argp5 = 0 ;
6201 int res5 = 0 ;
6202 int val6 ;
6203 int ecode6 = 0 ;
6204 int val7 ;
6205 int ecode7 = 0 ;
6206 bool val8 ;
6207 int ecode8 = 0 ;
6208 int val9 ;
6209 int ecode9 = 0 ;
6210 int val10 ;
6211 int ecode10 = 0 ;
6212 PyObject * obj0 = 0 ;
6213 PyObject * obj1 = 0 ;
6214 PyObject * obj2 = 0 ;
6215 PyObject * obj3 = 0 ;
6216 PyObject * obj4 = 0 ;
6217 PyObject * obj5 = 0 ;
6218 PyObject * obj6 = 0 ;
6219 PyObject * obj7 = 0 ;
6220 PyObject * obj8 = 0 ;
6221 char * kwnames[] = {
6222 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6223 };
6224
6225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6226 {
6227 arg1 = wxString_in_helper(obj0);
6228 if (arg1 == NULL) SWIG_fail;
6229 temp1 = true;
6230 }
6231 {
6232 arg2 = wxString_in_helper(obj1);
6233 if (arg2 == NULL) SWIG_fail;
6234 temp2 = true;
6235 }
6236 {
6237 arg3 = PyList_Size(obj2);
6238 arg4 = wxString_LIST_helper(obj2);
6239 if (arg4 == NULL) SWIG_fail;
6240 }
6241 if (obj3) {
6242 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6243 if (!SWIG_IsOK(res5)) {
6244 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6245 }
6246 arg5 = reinterpret_cast< wxWindow * >(argp5);
6247 }
6248 if (obj4) {
6249 ecode6 = SWIG_AsVal_int(obj4, &val6);
6250 if (!SWIG_IsOK(ecode6)) {
6251 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6252 }
6253 arg6 = static_cast< int >(val6);
6254 }
6255 if (obj5) {
6256 ecode7 = SWIG_AsVal_int(obj5, &val7);
6257 if (!SWIG_IsOK(ecode7)) {
6258 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6259 }
6260 arg7 = static_cast< int >(val7);
6261 }
6262 if (obj6) {
6263 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6264 if (!SWIG_IsOK(ecode8)) {
6265 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6266 }
6267 arg8 = static_cast< bool >(val8);
6268 }
6269 if (obj7) {
6270 ecode9 = SWIG_AsVal_int(obj7, &val9);
6271 if (!SWIG_IsOK(ecode9)) {
6272 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6273 }
6274 arg9 = static_cast< int >(val9);
6275 }
6276 if (obj8) {
6277 ecode10 = SWIG_AsVal_int(obj8, &val10);
6278 if (!SWIG_IsOK(ecode10)) {
6279 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6280 }
6281 arg10 = static_cast< int >(val10);
6282 }
6283 {
6284 if (!wxPyCheckForApp()) SWIG_fail;
6285 PyThreadState* __tstate = wxPyBeginAllowThreads();
6286 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6287 wxPyEndAllowThreads(__tstate);
6288 if (PyErr_Occurred()) SWIG_fail;
6289 }
6290 {
6291 #if wxUSE_UNICODE
6292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6293 #else
6294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6295 #endif
6296 }
6297 {
6298 if (temp1)
6299 delete arg1;
6300 }
6301 {
6302 if (temp2)
6303 delete arg2;
6304 }
6305 {
6306 if (arg4) delete [] arg4;
6307 }
6308 return resultobj;
6309 fail:
6310 {
6311 if (temp1)
6312 delete arg1;
6313 }
6314 {
6315 if (temp2)
6316 delete arg2;
6317 }
6318 {
6319 if (arg4) delete [] arg4;
6320 }
6321 return NULL;
6322 }
6323
6324
6325 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6326 PyObject *resultobj = 0;
6327 wxString *arg1 = 0 ;
6328 wxString *arg2 = 0 ;
6329 int arg3 ;
6330 wxString *arg4 = (wxString *) 0 ;
6331 wxWindow *arg5 = (wxWindow *) NULL ;
6332 int arg6 = (int) -1 ;
6333 int arg7 = (int) -1 ;
6334 bool arg8 = (bool) true ;
6335 int arg9 = (int) 150 ;
6336 int arg10 = (int) 200 ;
6337 int result;
6338 bool temp1 = false ;
6339 bool temp2 = false ;
6340 void *argp5 = 0 ;
6341 int res5 = 0 ;
6342 int val6 ;
6343 int ecode6 = 0 ;
6344 int val7 ;
6345 int ecode7 = 0 ;
6346 bool val8 ;
6347 int ecode8 = 0 ;
6348 int val9 ;
6349 int ecode9 = 0 ;
6350 int val10 ;
6351 int ecode10 = 0 ;
6352 PyObject * obj0 = 0 ;
6353 PyObject * obj1 = 0 ;
6354 PyObject * obj2 = 0 ;
6355 PyObject * obj3 = 0 ;
6356 PyObject * obj4 = 0 ;
6357 PyObject * obj5 = 0 ;
6358 PyObject * obj6 = 0 ;
6359 PyObject * obj7 = 0 ;
6360 PyObject * obj8 = 0 ;
6361 char * kwnames[] = {
6362 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6363 };
6364
6365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6366 {
6367 arg1 = wxString_in_helper(obj0);
6368 if (arg1 == NULL) SWIG_fail;
6369 temp1 = true;
6370 }
6371 {
6372 arg2 = wxString_in_helper(obj1);
6373 if (arg2 == NULL) SWIG_fail;
6374 temp2 = true;
6375 }
6376 {
6377 arg3 = PyList_Size(obj2);
6378 arg4 = wxString_LIST_helper(obj2);
6379 if (arg4 == NULL) SWIG_fail;
6380 }
6381 if (obj3) {
6382 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6383 if (!SWIG_IsOK(res5)) {
6384 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6385 }
6386 arg5 = reinterpret_cast< wxWindow * >(argp5);
6387 }
6388 if (obj4) {
6389 ecode6 = SWIG_AsVal_int(obj4, &val6);
6390 if (!SWIG_IsOK(ecode6)) {
6391 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6392 }
6393 arg6 = static_cast< int >(val6);
6394 }
6395 if (obj5) {
6396 ecode7 = SWIG_AsVal_int(obj5, &val7);
6397 if (!SWIG_IsOK(ecode7)) {
6398 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6399 }
6400 arg7 = static_cast< int >(val7);
6401 }
6402 if (obj6) {
6403 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6404 if (!SWIG_IsOK(ecode8)) {
6405 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6406 }
6407 arg8 = static_cast< bool >(val8);
6408 }
6409 if (obj7) {
6410 ecode9 = SWIG_AsVal_int(obj7, &val9);
6411 if (!SWIG_IsOK(ecode9)) {
6412 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6413 }
6414 arg9 = static_cast< int >(val9);
6415 }
6416 if (obj8) {
6417 ecode10 = SWIG_AsVal_int(obj8, &val10);
6418 if (!SWIG_IsOK(ecode10)) {
6419 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6420 }
6421 arg10 = static_cast< int >(val10);
6422 }
6423 {
6424 if (!wxPyCheckForApp()) SWIG_fail;
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_From_int(static_cast< int >(result));
6431 {
6432 if (temp1)
6433 delete arg1;
6434 }
6435 {
6436 if (temp2)
6437 delete arg2;
6438 }
6439 {
6440 if (arg4) delete [] arg4;
6441 }
6442 return resultobj;
6443 fail:
6444 {
6445 if (temp1)
6446 delete arg1;
6447 }
6448 {
6449 if (temp2)
6450 delete arg2;
6451 }
6452 {
6453 if (arg4) delete [] arg4;
6454 }
6455 return NULL;
6456 }
6457
6458
6459 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6460 PyObject *resultobj = 0;
6461 wxString *arg1 = 0 ;
6462 wxString const &arg2_defvalue = wxPyEmptyString ;
6463 wxString *arg2 = (wxString *) &arg2_defvalue ;
6464 int arg3 = (int) wxOK|wxCENTRE ;
6465 wxWindow *arg4 = (wxWindow *) NULL ;
6466 int arg5 = (int) -1 ;
6467 int arg6 = (int) -1 ;
6468 int result;
6469 bool temp1 = false ;
6470 bool temp2 = false ;
6471 int val3 ;
6472 int ecode3 = 0 ;
6473 void *argp4 = 0 ;
6474 int res4 = 0 ;
6475 int val5 ;
6476 int ecode5 = 0 ;
6477 int val6 ;
6478 int ecode6 = 0 ;
6479 PyObject * obj0 = 0 ;
6480 PyObject * obj1 = 0 ;
6481 PyObject * obj2 = 0 ;
6482 PyObject * obj3 = 0 ;
6483 PyObject * obj4 = 0 ;
6484 PyObject * obj5 = 0 ;
6485 char * kwnames[] = {
6486 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6487 };
6488
6489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6490 {
6491 arg1 = wxString_in_helper(obj0);
6492 if (arg1 == NULL) SWIG_fail;
6493 temp1 = true;
6494 }
6495 if (obj1) {
6496 {
6497 arg2 = wxString_in_helper(obj1);
6498 if (arg2 == NULL) SWIG_fail;
6499 temp2 = true;
6500 }
6501 }
6502 if (obj2) {
6503 ecode3 = SWIG_AsVal_int(obj2, &val3);
6504 if (!SWIG_IsOK(ecode3)) {
6505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6506 }
6507 arg3 = static_cast< int >(val3);
6508 }
6509 if (obj3) {
6510 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6511 if (!SWIG_IsOK(res4)) {
6512 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6513 }
6514 arg4 = reinterpret_cast< wxWindow * >(argp4);
6515 }
6516 if (obj4) {
6517 ecode5 = SWIG_AsVal_int(obj4, &val5);
6518 if (!SWIG_IsOK(ecode5)) {
6519 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6520 }
6521 arg5 = static_cast< int >(val5);
6522 }
6523 if (obj5) {
6524 ecode6 = SWIG_AsVal_int(obj5, &val6);
6525 if (!SWIG_IsOK(ecode6)) {
6526 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6527 }
6528 arg6 = static_cast< int >(val6);
6529 }
6530 {
6531 if (!wxPyCheckForApp()) SWIG_fail;
6532 PyThreadState* __tstate = wxPyBeginAllowThreads();
6533 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6534 wxPyEndAllowThreads(__tstate);
6535 if (PyErr_Occurred()) SWIG_fail;
6536 }
6537 resultobj = SWIG_From_int(static_cast< int >(result));
6538 {
6539 if (temp1)
6540 delete arg1;
6541 }
6542 {
6543 if (temp2)
6544 delete arg2;
6545 }
6546 return resultobj;
6547 fail:
6548 {
6549 if (temp1)
6550 delete arg1;
6551 }
6552 {
6553 if (temp2)
6554 delete arg2;
6555 }
6556 return NULL;
6557 }
6558
6559
6560 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6561 PyObject *resultobj = 0;
6562 wxString *arg1 = 0 ;
6563 wxString *arg2 = 0 ;
6564 wxString *arg3 = 0 ;
6565 long arg4 ;
6566 long arg5 = (long) 0 ;
6567 long arg6 = (long) 100 ;
6568 wxWindow *arg7 = (wxWindow *) NULL ;
6569 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6570 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6571 long result;
6572 bool temp1 = false ;
6573 bool temp2 = false ;
6574 bool temp3 = false ;
6575 long val4 ;
6576 int ecode4 = 0 ;
6577 long val5 ;
6578 int ecode5 = 0 ;
6579 long val6 ;
6580 int ecode6 = 0 ;
6581 void *argp7 = 0 ;
6582 int res7 = 0 ;
6583 wxPoint temp8 ;
6584 PyObject * obj0 = 0 ;
6585 PyObject * obj1 = 0 ;
6586 PyObject * obj2 = 0 ;
6587 PyObject * obj3 = 0 ;
6588 PyObject * obj4 = 0 ;
6589 PyObject * obj5 = 0 ;
6590 PyObject * obj6 = 0 ;
6591 PyObject * obj7 = 0 ;
6592 char * kwnames[] = {
6593 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6594 };
6595
6596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6597 {
6598 arg1 = wxString_in_helper(obj0);
6599 if (arg1 == NULL) SWIG_fail;
6600 temp1 = true;
6601 }
6602 {
6603 arg2 = wxString_in_helper(obj1);
6604 if (arg2 == NULL) SWIG_fail;
6605 temp2 = true;
6606 }
6607 {
6608 arg3 = wxString_in_helper(obj2);
6609 if (arg3 == NULL) SWIG_fail;
6610 temp3 = true;
6611 }
6612 ecode4 = SWIG_AsVal_long(obj3, &val4);
6613 if (!SWIG_IsOK(ecode4)) {
6614 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6615 }
6616 arg4 = static_cast< long >(val4);
6617 if (obj4) {
6618 ecode5 = SWIG_AsVal_long(obj4, &val5);
6619 if (!SWIG_IsOK(ecode5)) {
6620 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6621 }
6622 arg5 = static_cast< long >(val5);
6623 }
6624 if (obj5) {
6625 ecode6 = SWIG_AsVal_long(obj5, &val6);
6626 if (!SWIG_IsOK(ecode6)) {
6627 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6628 }
6629 arg6 = static_cast< long >(val6);
6630 }
6631 if (obj6) {
6632 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6633 if (!SWIG_IsOK(res7)) {
6634 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6635 }
6636 arg7 = reinterpret_cast< wxWindow * >(argp7);
6637 }
6638 if (obj7) {
6639 {
6640 arg8 = &temp8;
6641 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6642 }
6643 }
6644 {
6645 if (!wxPyCheckForApp()) SWIG_fail;
6646 PyThreadState* __tstate = wxPyBeginAllowThreads();
6647 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6648 wxPyEndAllowThreads(__tstate);
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 resultobj = SWIG_From_long(static_cast< long >(result));
6652 {
6653 if (temp1)
6654 delete arg1;
6655 }
6656 {
6657 if (temp2)
6658 delete arg2;
6659 }
6660 {
6661 if (temp3)
6662 delete arg3;
6663 }
6664 return resultobj;
6665 fail:
6666 {
6667 if (temp1)
6668 delete arg1;
6669 }
6670 {
6671 if (temp2)
6672 delete arg2;
6673 }
6674 {
6675 if (temp3)
6676 delete arg3;
6677 }
6678 return NULL;
6679 }
6680
6681
6682 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6683 PyObject *resultobj = 0;
6684 bool result;
6685
6686 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6687 {
6688 if (!wxPyCheckForApp()) SWIG_fail;
6689 PyThreadState* __tstate = wxPyBeginAllowThreads();
6690 result = (bool)wxColourDisplay();
6691 wxPyEndAllowThreads(__tstate);
6692 if (PyErr_Occurred()) SWIG_fail;
6693 }
6694 {
6695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6696 }
6697 return resultobj;
6698 fail:
6699 return NULL;
6700 }
6701
6702
6703 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6704 PyObject *resultobj = 0;
6705 int result;
6706
6707 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6708 {
6709 if (!wxPyCheckForApp()) SWIG_fail;
6710 PyThreadState* __tstate = wxPyBeginAllowThreads();
6711 result = (int)wxDisplayDepth();
6712 wxPyEndAllowThreads(__tstate);
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 resultobj = SWIG_From_int(static_cast< int >(result));
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6723 PyObject *resultobj = 0;
6724 int result;
6725
6726 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6727 {
6728 if (!wxPyCheckForApp()) SWIG_fail;
6729 PyThreadState* __tstate = wxPyBeginAllowThreads();
6730 result = (int)wxGetDisplayDepth();
6731 wxPyEndAllowThreads(__tstate);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 resultobj = SWIG_From_int(static_cast< int >(result));
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6742 PyObject *resultobj = 0;
6743 int *arg1 = (int *) 0 ;
6744 int *arg2 = (int *) 0 ;
6745 int temp1 ;
6746 int res1 = SWIG_TMPOBJ ;
6747 int temp2 ;
6748 int res2 = SWIG_TMPOBJ ;
6749
6750 arg1 = &temp1;
6751 arg2 = &temp2;
6752 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6753 {
6754 if (!wxPyCheckForApp()) SWIG_fail;
6755 PyThreadState* __tstate = wxPyBeginAllowThreads();
6756 wxDisplaySize(arg1,arg2);
6757 wxPyEndAllowThreads(__tstate);
6758 if (PyErr_Occurred()) SWIG_fail;
6759 }
6760 resultobj = SWIG_Py_Void();
6761 if (SWIG_IsTmpObj(res1)) {
6762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6763 } else {
6764 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6766 }
6767 if (SWIG_IsTmpObj(res2)) {
6768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6769 } else {
6770 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6772 }
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6780 PyObject *resultobj = 0;
6781 wxSize result;
6782
6783 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6784 {
6785 if (!wxPyCheckForApp()) SWIG_fail;
6786 PyThreadState* __tstate = wxPyBeginAllowThreads();
6787 result = wxGetDisplaySize();
6788 wxPyEndAllowThreads(__tstate);
6789 if (PyErr_Occurred()) SWIG_fail;
6790 }
6791 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6792 return resultobj;
6793 fail:
6794 return NULL;
6795 }
6796
6797
6798 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6799 PyObject *resultobj = 0;
6800 int *arg1 = (int *) 0 ;
6801 int *arg2 = (int *) 0 ;
6802 int temp1 ;
6803 int res1 = SWIG_TMPOBJ ;
6804 int temp2 ;
6805 int res2 = SWIG_TMPOBJ ;
6806
6807 arg1 = &temp1;
6808 arg2 = &temp2;
6809 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6810 {
6811 if (!wxPyCheckForApp()) SWIG_fail;
6812 PyThreadState* __tstate = wxPyBeginAllowThreads();
6813 wxDisplaySizeMM(arg1,arg2);
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 resultobj = SWIG_Py_Void();
6818 if (SWIG_IsTmpObj(res1)) {
6819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6820 } else {
6821 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6823 }
6824 if (SWIG_IsTmpObj(res2)) {
6825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6826 } else {
6827 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6829 }
6830 return resultobj;
6831 fail:
6832 return NULL;
6833 }
6834
6835
6836 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6837 PyObject *resultobj = 0;
6838 wxSize result;
6839
6840 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6841 {
6842 if (!wxPyCheckForApp()) SWIG_fail;
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = wxGetDisplaySizeMM();
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6856 PyObject *resultobj = 0;
6857 int *arg1 = (int *) 0 ;
6858 int *arg2 = (int *) 0 ;
6859 int *arg3 = (int *) 0 ;
6860 int *arg4 = (int *) 0 ;
6861 int temp1 ;
6862 int res1 = SWIG_TMPOBJ ;
6863 int temp2 ;
6864 int res2 = SWIG_TMPOBJ ;
6865 int temp3 ;
6866 int res3 = SWIG_TMPOBJ ;
6867 int temp4 ;
6868 int res4 = SWIG_TMPOBJ ;
6869
6870 arg1 = &temp1;
6871 arg2 = &temp2;
6872 arg3 = &temp3;
6873 arg4 = &temp4;
6874 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6875 {
6876 if (!wxPyCheckForApp()) SWIG_fail;
6877 PyThreadState* __tstate = wxPyBeginAllowThreads();
6878 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6879 wxPyEndAllowThreads(__tstate);
6880 if (PyErr_Occurred()) SWIG_fail;
6881 }
6882 resultobj = SWIG_Py_Void();
6883 if (SWIG_IsTmpObj(res1)) {
6884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6885 } else {
6886 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6888 }
6889 if (SWIG_IsTmpObj(res2)) {
6890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6891 } else {
6892 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6894 }
6895 if (SWIG_IsTmpObj(res3)) {
6896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6897 } else {
6898 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6900 }
6901 if (SWIG_IsTmpObj(res4)) {
6902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6903 } else {
6904 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6906 }
6907 return resultobj;
6908 fail:
6909 return NULL;
6910 }
6911
6912
6913 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6914 PyObject *resultobj = 0;
6915 wxRect result;
6916
6917 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6918 {
6919 if (!wxPyCheckForApp()) SWIG_fail;
6920 PyThreadState* __tstate = wxPyBeginAllowThreads();
6921 result = wxGetClientDisplayRect();
6922 wxPyEndAllowThreads(__tstate);
6923 if (PyErr_Occurred()) SWIG_fail;
6924 }
6925 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6926 return resultobj;
6927 fail:
6928 return NULL;
6929 }
6930
6931
6932 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6933 PyObject *resultobj = 0;
6934 wxCursor *arg1 = 0 ;
6935 void *argp1 = 0 ;
6936 int res1 = 0 ;
6937 PyObject * obj0 = 0 ;
6938 char * kwnames[] = {
6939 (char *) "cursor", NULL
6940 };
6941
6942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6943 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6944 if (!SWIG_IsOK(res1)) {
6945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6946 }
6947 if (!argp1) {
6948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6949 }
6950 arg1 = reinterpret_cast< wxCursor * >(argp1);
6951 {
6952 if (!wxPyCheckForApp()) SWIG_fail;
6953 PyThreadState* __tstate = wxPyBeginAllowThreads();
6954 wxSetCursor(*arg1);
6955 wxPyEndAllowThreads(__tstate);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 resultobj = SWIG_Py_Void();
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6966 PyObject *resultobj = 0;
6967 void *result = 0 ;
6968
6969 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6970 {
6971 if (!wxPyCheckForApp()) SWIG_fail;
6972 PyThreadState* __tstate = wxPyBeginAllowThreads();
6973 result = (void *)wxGetXDisplay();
6974 wxPyEndAllowThreads(__tstate);
6975 if (PyErr_Occurred()) SWIG_fail;
6976 }
6977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6978 return resultobj;
6979 fail:
6980 return NULL;
6981 }
6982
6983
6984 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6985 PyObject *resultobj = 0;
6986 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6987 void *argp1 = 0 ;
6988 int res1 = 0 ;
6989 PyObject * obj0 = 0 ;
6990 char * kwnames[] = {
6991 (char *) "cursor", NULL
6992 };
6993
6994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6995 if (obj0) {
6996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6997 if (!SWIG_IsOK(res1)) {
6998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6999 }
7000 arg1 = reinterpret_cast< wxCursor * >(argp1);
7001 }
7002 {
7003 if (!wxPyCheckForApp()) SWIG_fail;
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 wxBeginBusyCursor(arg1);
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_Py_Void();
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7017 PyObject *resultobj = 0;
7018 wxPoint result;
7019
7020 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7021 {
7022 if (!wxPyCheckForApp()) SWIG_fail;
7023 PyThreadState* __tstate = wxPyBeginAllowThreads();
7024 result = wxGetMousePosition();
7025 wxPyEndAllowThreads(__tstate);
7026 if (PyErr_Occurred()) SWIG_fail;
7027 }
7028 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7029 return resultobj;
7030 fail:
7031 return NULL;
7032 }
7033
7034
7035 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7036 PyObject *resultobj = 0;
7037 wxWindow *result = 0 ;
7038
7039 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7040 {
7041 if (!wxPyCheckForApp()) SWIG_fail;
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 result = (wxWindow *)FindWindowAtPointer();
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 {
7048 resultobj = wxPyMake_wxObject(result, 0);
7049 }
7050 return resultobj;
7051 fail:
7052 return NULL;
7053 }
7054
7055
7056 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7057 PyObject *resultobj = 0;
7058 wxWindow *result = 0 ;
7059
7060 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7061 {
7062 if (!wxPyCheckForApp()) SWIG_fail;
7063 PyThreadState* __tstate = wxPyBeginAllowThreads();
7064 result = (wxWindow *)wxGetActiveWindow();
7065 wxPyEndAllowThreads(__tstate);
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 {
7069 resultobj = wxPyMake_wxObject(result, 0);
7070 }
7071 return resultobj;
7072 fail:
7073 return NULL;
7074 }
7075
7076
7077 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7078 PyObject *resultobj = 0;
7079 wxPoint *arg1 = 0 ;
7080 wxWindow *result = 0 ;
7081 wxPoint temp1 ;
7082 PyObject * obj0 = 0 ;
7083 char * kwnames[] = {
7084 (char *) "pt", NULL
7085 };
7086
7087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7088 {
7089 arg1 = &temp1;
7090 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7091 }
7092 {
7093 if (!wxPyCheckForApp()) SWIG_fail;
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 {
7100 resultobj = wxPyMake_wxObject(result, 0);
7101 }
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7109 PyObject *resultobj = 0;
7110 wxPoint *arg1 = 0 ;
7111 wxWindow *result = 0 ;
7112 wxPoint temp1 ;
7113 PyObject * obj0 = 0 ;
7114 char * kwnames[] = {
7115 (char *) "pt", NULL
7116 };
7117
7118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7119 {
7120 arg1 = &temp1;
7121 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7122 }
7123 {
7124 if (!wxPyCheckForApp()) SWIG_fail;
7125 PyThreadState* __tstate = wxPyBeginAllowThreads();
7126 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7127 wxPyEndAllowThreads(__tstate);
7128 if (PyErr_Occurred()) SWIG_fail;
7129 }
7130 {
7131 resultobj = wxPyMake_wxObject(result, 0);
7132 }
7133 return resultobj;
7134 fail:
7135 return NULL;
7136 }
7137
7138
7139 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7140 PyObject *resultobj = 0;
7141 wxWindow *arg1 = (wxWindow *) 0 ;
7142 wxWindow *result = 0 ;
7143 void *argp1 = 0 ;
7144 int res1 = 0 ;
7145 PyObject * obj0 = 0 ;
7146 char * kwnames[] = {
7147 (char *) "win", NULL
7148 };
7149
7150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7152 if (!SWIG_IsOK(res1)) {
7153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7154 }
7155 arg1 = reinterpret_cast< wxWindow * >(argp1);
7156 {
7157 if (!wxPyCheckForApp()) SWIG_fail;
7158 PyThreadState* __tstate = wxPyBeginAllowThreads();
7159 result = (wxWindow *)wxGetTopLevelParent(arg1);
7160 wxPyEndAllowThreads(__tstate);
7161 if (PyErr_Occurred()) SWIG_fail;
7162 }
7163 {
7164 resultobj = wxPyMake_wxObject(result, 0);
7165 }
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7173 PyObject *resultobj = 0;
7174 wxString *arg1 = 0 ;
7175 bool result;
7176 bool temp1 = false ;
7177 PyObject * obj0 = 0 ;
7178 char * kwnames[] = {
7179 (char *) "url", NULL
7180 };
7181
7182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7183 {
7184 arg1 = wxString_in_helper(obj0);
7185 if (arg1 == NULL) SWIG_fail;
7186 temp1 = true;
7187 }
7188 {
7189 PyThreadState* __tstate = wxPyBeginAllowThreads();
7190 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7191 wxPyEndAllowThreads(__tstate);
7192 if (PyErr_Occurred()) SWIG_fail;
7193 }
7194 {
7195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7196 }
7197 {
7198 if (temp1)
7199 delete arg1;
7200 }
7201 return resultobj;
7202 fail:
7203 {
7204 if (temp1)
7205 delete arg1;
7206 }
7207 return NULL;
7208 }
7209
7210
7211 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7212 PyObject *resultobj = 0;
7213 wxKeyCode arg1 ;
7214 bool result;
7215 int val1 ;
7216 int ecode1 = 0 ;
7217 PyObject * obj0 = 0 ;
7218 char * kwnames[] = {
7219 (char *) "key", NULL
7220 };
7221
7222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7223 ecode1 = SWIG_AsVal_int(obj0, &val1);
7224 if (!SWIG_IsOK(ecode1)) {
7225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7226 }
7227 arg1 = static_cast< wxKeyCode >(val1);
7228 {
7229 if (!wxPyCheckForApp()) SWIG_fail;
7230 PyThreadState* __tstate = wxPyBeginAllowThreads();
7231 result = (bool)wxGetKeyState(arg1);
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 {
7236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7237 }
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7245 PyObject *resultobj = 0;
7246 wxMouseState *result = 0 ;
7247
7248 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7249 {
7250 PyThreadState* __tstate = wxPyBeginAllowThreads();
7251 result = (wxMouseState *)new wxMouseState();
7252 wxPyEndAllowThreads(__tstate);
7253 if (PyErr_Occurred()) SWIG_fail;
7254 }
7255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7263 PyObject *resultobj = 0;
7264 wxMouseState *arg1 = (wxMouseState *) 0 ;
7265 void *argp1 = 0 ;
7266 int res1 = 0 ;
7267 PyObject *swig_obj[1] ;
7268
7269 if (!args) SWIG_fail;
7270 swig_obj[0] = args;
7271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7272 if (!SWIG_IsOK(res1)) {
7273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7274 }
7275 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7276 {
7277 PyThreadState* __tstate = wxPyBeginAllowThreads();
7278 delete arg1;
7279
7280 wxPyEndAllowThreads(__tstate);
7281 if (PyErr_Occurred()) SWIG_fail;
7282 }
7283 resultobj = SWIG_Py_Void();
7284 return resultobj;
7285 fail:
7286 return NULL;
7287 }
7288
7289
7290 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7291 PyObject *resultobj = 0;
7292 wxMouseState *arg1 = (wxMouseState *) 0 ;
7293 int result;
7294 void *argp1 = 0 ;
7295 int res1 = 0 ;
7296 PyObject *swig_obj[1] ;
7297
7298 if (!args) SWIG_fail;
7299 swig_obj[0] = args;
7300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7301 if (!SWIG_IsOK(res1)) {
7302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7303 }
7304 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7305 {
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 result = (int)(arg1)->GetX();
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 resultobj = SWIG_From_int(static_cast< int >(result));
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7319 PyObject *resultobj = 0;
7320 wxMouseState *arg1 = (wxMouseState *) 0 ;
7321 int result;
7322 void *argp1 = 0 ;
7323 int res1 = 0 ;
7324 PyObject *swig_obj[1] ;
7325
7326 if (!args) SWIG_fail;
7327 swig_obj[0] = args;
7328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7329 if (!SWIG_IsOK(res1)) {
7330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7331 }
7332 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7333 {
7334 PyThreadState* __tstate = wxPyBeginAllowThreads();
7335 result = (int)(arg1)->GetY();
7336 wxPyEndAllowThreads(__tstate);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 resultobj = SWIG_From_int(static_cast< int >(result));
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7347 PyObject *resultobj = 0;
7348 wxMouseState *arg1 = (wxMouseState *) 0 ;
7349 bool result;
7350 void *argp1 = 0 ;
7351 int res1 = 0 ;
7352 PyObject *swig_obj[1] ;
7353
7354 if (!args) SWIG_fail;
7355 swig_obj[0] = args;
7356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7357 if (!SWIG_IsOK(res1)) {
7358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7359 }
7360 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7361 {
7362 PyThreadState* __tstate = wxPyBeginAllowThreads();
7363 result = (bool)(arg1)->LeftDown();
7364 wxPyEndAllowThreads(__tstate);
7365 if (PyErr_Occurred()) SWIG_fail;
7366 }
7367 {
7368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7369 }
7370 return resultobj;
7371 fail:
7372 return NULL;
7373 }
7374
7375
7376 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7377 PyObject *resultobj = 0;
7378 wxMouseState *arg1 = (wxMouseState *) 0 ;
7379 bool result;
7380 void *argp1 = 0 ;
7381 int res1 = 0 ;
7382 PyObject *swig_obj[1] ;
7383
7384 if (!args) SWIG_fail;
7385 swig_obj[0] = args;
7386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7387 if (!SWIG_IsOK(res1)) {
7388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7389 }
7390 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7391 {
7392 PyThreadState* __tstate = wxPyBeginAllowThreads();
7393 result = (bool)(arg1)->MiddleDown();
7394 wxPyEndAllowThreads(__tstate);
7395 if (PyErr_Occurred()) SWIG_fail;
7396 }
7397 {
7398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7399 }
7400 return resultobj;
7401 fail:
7402 return NULL;
7403 }
7404
7405
7406 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7407 PyObject *resultobj = 0;
7408 wxMouseState *arg1 = (wxMouseState *) 0 ;
7409 bool result;
7410 void *argp1 = 0 ;
7411 int res1 = 0 ;
7412 PyObject *swig_obj[1] ;
7413
7414 if (!args) SWIG_fail;
7415 swig_obj[0] = args;
7416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7417 if (!SWIG_IsOK(res1)) {
7418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7419 }
7420 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7421 {
7422 PyThreadState* __tstate = wxPyBeginAllowThreads();
7423 result = (bool)(arg1)->RightDown();
7424 wxPyEndAllowThreads(__tstate);
7425 if (PyErr_Occurred()) SWIG_fail;
7426 }
7427 {
7428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7429 }
7430 return resultobj;
7431 fail:
7432 return NULL;
7433 }
7434
7435
7436 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7437 PyObject *resultobj = 0;
7438 wxMouseState *arg1 = (wxMouseState *) 0 ;
7439 bool result;
7440 void *argp1 = 0 ;
7441 int res1 = 0 ;
7442 PyObject *swig_obj[1] ;
7443
7444 if (!args) SWIG_fail;
7445 swig_obj[0] = args;
7446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7447 if (!SWIG_IsOK(res1)) {
7448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7449 }
7450 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7451 {
7452 PyThreadState* __tstate = wxPyBeginAllowThreads();
7453 result = (bool)(arg1)->ControlDown();
7454 wxPyEndAllowThreads(__tstate);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 {
7458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7459 }
7460 return resultobj;
7461 fail:
7462 return NULL;
7463 }
7464
7465
7466 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7467 PyObject *resultobj = 0;
7468 wxMouseState *arg1 = (wxMouseState *) 0 ;
7469 bool result;
7470 void *argp1 = 0 ;
7471 int res1 = 0 ;
7472 PyObject *swig_obj[1] ;
7473
7474 if (!args) SWIG_fail;
7475 swig_obj[0] = args;
7476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7477 if (!SWIG_IsOK(res1)) {
7478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7479 }
7480 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (bool)(arg1)->ShiftDown();
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 {
7488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7489 }
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7497 PyObject *resultobj = 0;
7498 wxMouseState *arg1 = (wxMouseState *) 0 ;
7499 bool result;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 PyObject *swig_obj[1] ;
7503
7504 if (!args) SWIG_fail;
7505 swig_obj[0] = args;
7506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7507 if (!SWIG_IsOK(res1)) {
7508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7509 }
7510 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7511 {
7512 PyThreadState* __tstate = wxPyBeginAllowThreads();
7513 result = (bool)(arg1)->AltDown();
7514 wxPyEndAllowThreads(__tstate);
7515 if (PyErr_Occurred()) SWIG_fail;
7516 }
7517 {
7518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7519 }
7520 return resultobj;
7521 fail:
7522 return NULL;
7523 }
7524
7525
7526 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7527 PyObject *resultobj = 0;
7528 wxMouseState *arg1 = (wxMouseState *) 0 ;
7529 bool result;
7530 void *argp1 = 0 ;
7531 int res1 = 0 ;
7532 PyObject *swig_obj[1] ;
7533
7534 if (!args) SWIG_fail;
7535 swig_obj[0] = args;
7536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7537 if (!SWIG_IsOK(res1)) {
7538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7539 }
7540 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7541 {
7542 PyThreadState* __tstate = wxPyBeginAllowThreads();
7543 result = (bool)(arg1)->MetaDown();
7544 wxPyEndAllowThreads(__tstate);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 {
7548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7549 }
7550 return resultobj;
7551 fail:
7552 return NULL;
7553 }
7554
7555
7556 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7557 PyObject *resultobj = 0;
7558 wxMouseState *arg1 = (wxMouseState *) 0 ;
7559 bool result;
7560 void *argp1 = 0 ;
7561 int res1 = 0 ;
7562 PyObject *swig_obj[1] ;
7563
7564 if (!args) SWIG_fail;
7565 swig_obj[0] = args;
7566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7567 if (!SWIG_IsOK(res1)) {
7568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7569 }
7570 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 result = (bool)(arg1)->CmdDown();
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 {
7578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7579 }
7580 return resultobj;
7581 fail:
7582 return NULL;
7583 }
7584
7585
7586 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7587 PyObject *resultobj = 0;
7588 wxMouseState *arg1 = (wxMouseState *) 0 ;
7589 int arg2 ;
7590 void *argp1 = 0 ;
7591 int res1 = 0 ;
7592 int val2 ;
7593 int ecode2 = 0 ;
7594 PyObject * obj0 = 0 ;
7595 PyObject * obj1 = 0 ;
7596 char * kwnames[] = {
7597 (char *) "self",(char *) "x", NULL
7598 };
7599
7600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7602 if (!SWIG_IsOK(res1)) {
7603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7604 }
7605 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7606 ecode2 = SWIG_AsVal_int(obj1, &val2);
7607 if (!SWIG_IsOK(ecode2)) {
7608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7609 }
7610 arg2 = static_cast< int >(val2);
7611 {
7612 PyThreadState* __tstate = wxPyBeginAllowThreads();
7613 (arg1)->SetX(arg2);
7614 wxPyEndAllowThreads(__tstate);
7615 if (PyErr_Occurred()) SWIG_fail;
7616 }
7617 resultobj = SWIG_Py_Void();
7618 return resultobj;
7619 fail:
7620 return NULL;
7621 }
7622
7623
7624 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj = 0;
7626 wxMouseState *arg1 = (wxMouseState *) 0 ;
7627 int arg2 ;
7628 void *argp1 = 0 ;
7629 int res1 = 0 ;
7630 int val2 ;
7631 int ecode2 = 0 ;
7632 PyObject * obj0 = 0 ;
7633 PyObject * obj1 = 0 ;
7634 char * kwnames[] = {
7635 (char *) "self",(char *) "y", NULL
7636 };
7637
7638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7640 if (!SWIG_IsOK(res1)) {
7641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7642 }
7643 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7644 ecode2 = SWIG_AsVal_int(obj1, &val2);
7645 if (!SWIG_IsOK(ecode2)) {
7646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7647 }
7648 arg2 = static_cast< int >(val2);
7649 {
7650 PyThreadState* __tstate = wxPyBeginAllowThreads();
7651 (arg1)->SetY(arg2);
7652 wxPyEndAllowThreads(__tstate);
7653 if (PyErr_Occurred()) SWIG_fail;
7654 }
7655 resultobj = SWIG_Py_Void();
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj = 0;
7664 wxMouseState *arg1 = (wxMouseState *) 0 ;
7665 bool arg2 ;
7666 void *argp1 = 0 ;
7667 int res1 = 0 ;
7668 bool val2 ;
7669 int ecode2 = 0 ;
7670 PyObject * obj0 = 0 ;
7671 PyObject * obj1 = 0 ;
7672 char * kwnames[] = {
7673 (char *) "self",(char *) "down", NULL
7674 };
7675
7676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7678 if (!SWIG_IsOK(res1)) {
7679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7680 }
7681 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7682 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7683 if (!SWIG_IsOK(ecode2)) {
7684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7685 }
7686 arg2 = static_cast< bool >(val2);
7687 {
7688 PyThreadState* __tstate = wxPyBeginAllowThreads();
7689 (arg1)->SetLeftDown(arg2);
7690 wxPyEndAllowThreads(__tstate);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 resultobj = SWIG_Py_Void();
7694 return resultobj;
7695 fail:
7696 return NULL;
7697 }
7698
7699
7700 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7701 PyObject *resultobj = 0;
7702 wxMouseState *arg1 = (wxMouseState *) 0 ;
7703 bool arg2 ;
7704 void *argp1 = 0 ;
7705 int res1 = 0 ;
7706 bool val2 ;
7707 int ecode2 = 0 ;
7708 PyObject * obj0 = 0 ;
7709 PyObject * obj1 = 0 ;
7710 char * kwnames[] = {
7711 (char *) "self",(char *) "down", NULL
7712 };
7713
7714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7716 if (!SWIG_IsOK(res1)) {
7717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7718 }
7719 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7720 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7721 if (!SWIG_IsOK(ecode2)) {
7722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7723 }
7724 arg2 = static_cast< bool >(val2);
7725 {
7726 PyThreadState* __tstate = wxPyBeginAllowThreads();
7727 (arg1)->SetMiddleDown(arg2);
7728 wxPyEndAllowThreads(__tstate);
7729 if (PyErr_Occurred()) SWIG_fail;
7730 }
7731 resultobj = SWIG_Py_Void();
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7739 PyObject *resultobj = 0;
7740 wxMouseState *arg1 = (wxMouseState *) 0 ;
7741 bool arg2 ;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 bool val2 ;
7745 int ecode2 = 0 ;
7746 PyObject * obj0 = 0 ;
7747 PyObject * obj1 = 0 ;
7748 char * kwnames[] = {
7749 (char *) "self",(char *) "down", NULL
7750 };
7751
7752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7754 if (!SWIG_IsOK(res1)) {
7755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7756 }
7757 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7758 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7759 if (!SWIG_IsOK(ecode2)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7761 }
7762 arg2 = static_cast< bool >(val2);
7763 {
7764 PyThreadState* __tstate = wxPyBeginAllowThreads();
7765 (arg1)->SetRightDown(arg2);
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 resultobj = SWIG_Py_Void();
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7777 PyObject *resultobj = 0;
7778 wxMouseState *arg1 = (wxMouseState *) 0 ;
7779 bool arg2 ;
7780 void *argp1 = 0 ;
7781 int res1 = 0 ;
7782 bool val2 ;
7783 int ecode2 = 0 ;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 char * kwnames[] = {
7787 (char *) "self",(char *) "down", NULL
7788 };
7789
7790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7794 }
7795 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7796 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7797 if (!SWIG_IsOK(ecode2)) {
7798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7799 }
7800 arg2 = static_cast< bool >(val2);
7801 {
7802 PyThreadState* __tstate = wxPyBeginAllowThreads();
7803 (arg1)->SetControlDown(arg2);
7804 wxPyEndAllowThreads(__tstate);
7805 if (PyErr_Occurred()) SWIG_fail;
7806 }
7807 resultobj = SWIG_Py_Void();
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj = 0;
7816 wxMouseState *arg1 = (wxMouseState *) 0 ;
7817 bool arg2 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 bool val2 ;
7821 int ecode2 = 0 ;
7822 PyObject * obj0 = 0 ;
7823 PyObject * obj1 = 0 ;
7824 char * kwnames[] = {
7825 (char *) "self",(char *) "down", NULL
7826 };
7827
7828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7830 if (!SWIG_IsOK(res1)) {
7831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7832 }
7833 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7834 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7835 if (!SWIG_IsOK(ecode2)) {
7836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7837 }
7838 arg2 = static_cast< bool >(val2);
7839 {
7840 PyThreadState* __tstate = wxPyBeginAllowThreads();
7841 (arg1)->SetShiftDown(arg2);
7842 wxPyEndAllowThreads(__tstate);
7843 if (PyErr_Occurred()) SWIG_fail;
7844 }
7845 resultobj = SWIG_Py_Void();
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7853 PyObject *resultobj = 0;
7854 wxMouseState *arg1 = (wxMouseState *) 0 ;
7855 bool arg2 ;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 bool val2 ;
7859 int ecode2 = 0 ;
7860 PyObject * obj0 = 0 ;
7861 PyObject * obj1 = 0 ;
7862 char * kwnames[] = {
7863 (char *) "self",(char *) "down", NULL
7864 };
7865
7866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7868 if (!SWIG_IsOK(res1)) {
7869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7870 }
7871 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7873 if (!SWIG_IsOK(ecode2)) {
7874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7875 }
7876 arg2 = static_cast< bool >(val2);
7877 {
7878 PyThreadState* __tstate = wxPyBeginAllowThreads();
7879 (arg1)->SetAltDown(arg2);
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 resultobj = SWIG_Py_Void();
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7891 PyObject *resultobj = 0;
7892 wxMouseState *arg1 = (wxMouseState *) 0 ;
7893 bool arg2 ;
7894 void *argp1 = 0 ;
7895 int res1 = 0 ;
7896 bool val2 ;
7897 int ecode2 = 0 ;
7898 PyObject * obj0 = 0 ;
7899 PyObject * obj1 = 0 ;
7900 char * kwnames[] = {
7901 (char *) "self",(char *) "down", NULL
7902 };
7903
7904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7906 if (!SWIG_IsOK(res1)) {
7907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7908 }
7909 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7910 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7911 if (!SWIG_IsOK(ecode2)) {
7912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7913 }
7914 arg2 = static_cast< bool >(val2);
7915 {
7916 PyThreadState* __tstate = wxPyBeginAllowThreads();
7917 (arg1)->SetMetaDown(arg2);
7918 wxPyEndAllowThreads(__tstate);
7919 if (PyErr_Occurred()) SWIG_fail;
7920 }
7921 resultobj = SWIG_Py_Void();
7922 return resultobj;
7923 fail:
7924 return NULL;
7925 }
7926
7927
7928 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7929 PyObject *obj;
7930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7931 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7932 return SWIG_Py_Void();
7933 }
7934
7935 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7936 return SWIG_Python_InitShadowInstance(args);
7937 }
7938
7939 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7940 PyObject *resultobj = 0;
7941 wxMouseState result;
7942
7943 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7944 {
7945 PyThreadState* __tstate = wxPyBeginAllowThreads();
7946 result = wxGetMouseState();
7947 wxPyEndAllowThreads(__tstate);
7948 if (PyErr_Occurred()) SWIG_fail;
7949 }
7950 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7951 return resultobj;
7952 fail:
7953 return NULL;
7954 }
7955
7956
7957 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7958 PyObject *resultobj = 0;
7959
7960 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7961 {
7962 if (!wxPyCheckForApp()) SWIG_fail;
7963 PyThreadState* __tstate = wxPyBeginAllowThreads();
7964 wxWakeUpMainThread();
7965 wxPyEndAllowThreads(__tstate);
7966 if (PyErr_Occurred()) SWIG_fail;
7967 }
7968 resultobj = SWIG_Py_Void();
7969 return resultobj;
7970 fail:
7971 return NULL;
7972 }
7973
7974
7975 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7976 PyObject *resultobj = 0;
7977
7978 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7979 {
7980 if (!wxPyCheckForApp()) SWIG_fail;
7981 PyThreadState* __tstate = wxPyBeginAllowThreads();
7982 wxMutexGuiEnter();
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 resultobj = SWIG_Py_Void();
7987 return resultobj;
7988 fail:
7989 return NULL;
7990 }
7991
7992
7993 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7994 PyObject *resultobj = 0;
7995
7996 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7997 {
7998 if (!wxPyCheckForApp()) SWIG_fail;
7999 PyThreadState* __tstate = wxPyBeginAllowThreads();
8000 wxMutexGuiLeave();
8001 wxPyEndAllowThreads(__tstate);
8002 if (PyErr_Occurred()) SWIG_fail;
8003 }
8004 resultobj = SWIG_Py_Void();
8005 return resultobj;
8006 fail:
8007 return NULL;
8008 }
8009
8010
8011 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8012 PyObject *resultobj = 0;
8013 wxMutexGuiLocker *result = 0 ;
8014
8015 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8016 {
8017 if (!wxPyCheckForApp()) SWIG_fail;
8018 PyThreadState* __tstate = wxPyBeginAllowThreads();
8019 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8020 wxPyEndAllowThreads(__tstate);
8021 if (PyErr_Occurred()) SWIG_fail;
8022 }
8023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8024 return resultobj;
8025 fail:
8026 return NULL;
8027 }
8028
8029
8030 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8031 PyObject *resultobj = 0;
8032 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8033 void *argp1 = 0 ;
8034 int res1 = 0 ;
8035 PyObject *swig_obj[1] ;
8036
8037 if (!args) SWIG_fail;
8038 swig_obj[0] = args;
8039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8040 if (!SWIG_IsOK(res1)) {
8041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8042 }
8043 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8044 {
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 delete arg1;
8047
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = SWIG_Py_Void();
8052 return resultobj;
8053 fail:
8054 return NULL;
8055 }
8056
8057
8058 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8059 PyObject *obj;
8060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8061 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8062 return SWIG_Py_Void();
8063 }
8064
8065 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8066 return SWIG_Python_InitShadowInstance(args);
8067 }
8068
8069 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071 bool result;
8072
8073 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8074 {
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 result = (bool)wxThread_IsMain();
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 {
8081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8082 }
8083 return resultobj;
8084 fail:
8085 return NULL;
8086 }
8087
8088
8089 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8090 PyObject *resultobj = 0;
8091 wxString *arg1 = 0 ;
8092 wxToolTip *result = 0 ;
8093 bool temp1 = false ;
8094 PyObject * obj0 = 0 ;
8095 char * kwnames[] = {
8096 (char *) "tip", NULL
8097 };
8098
8099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8100 {
8101 arg1 = wxString_in_helper(obj0);
8102 if (arg1 == NULL) SWIG_fail;
8103 temp1 = true;
8104 }
8105 {
8106 if (!wxPyCheckForApp()) SWIG_fail;
8107 PyThreadState* __tstate = wxPyBeginAllowThreads();
8108 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8109 wxPyEndAllowThreads(__tstate);
8110 if (PyErr_Occurred()) SWIG_fail;
8111 }
8112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8113 {
8114 if (temp1)
8115 delete arg1;
8116 }
8117 return resultobj;
8118 fail:
8119 {
8120 if (temp1)
8121 delete arg1;
8122 }
8123 return NULL;
8124 }
8125
8126
8127 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8128 PyObject *resultobj = 0;
8129 wxToolTip *arg1 = (wxToolTip *) 0 ;
8130 void *argp1 = 0 ;
8131 int res1 = 0 ;
8132 PyObject *swig_obj[1] ;
8133
8134 if (!args) SWIG_fail;
8135 swig_obj[0] = args;
8136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8137 if (!SWIG_IsOK(res1)) {
8138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8139 }
8140 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8141 {
8142 PyThreadState* __tstate = wxPyBeginAllowThreads();
8143 delete arg1;
8144
8145 wxPyEndAllowThreads(__tstate);
8146 if (PyErr_Occurred()) SWIG_fail;
8147 }
8148 resultobj = SWIG_Py_Void();
8149 return resultobj;
8150 fail:
8151 return NULL;
8152 }
8153
8154
8155 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8156 PyObject *resultobj = 0;
8157 wxToolTip *arg1 = (wxToolTip *) 0 ;
8158 wxString *arg2 = 0 ;
8159 void *argp1 = 0 ;
8160 int res1 = 0 ;
8161 bool temp2 = false ;
8162 PyObject * obj0 = 0 ;
8163 PyObject * obj1 = 0 ;
8164 char * kwnames[] = {
8165 (char *) "self",(char *) "tip", NULL
8166 };
8167
8168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8170 if (!SWIG_IsOK(res1)) {
8171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8172 }
8173 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8174 {
8175 arg2 = wxString_in_helper(obj1);
8176 if (arg2 == NULL) SWIG_fail;
8177 temp2 = true;
8178 }
8179 {
8180 PyThreadState* __tstate = wxPyBeginAllowThreads();
8181 (arg1)->SetTip((wxString const &)*arg2);
8182 wxPyEndAllowThreads(__tstate);
8183 if (PyErr_Occurred()) SWIG_fail;
8184 }
8185 resultobj = SWIG_Py_Void();
8186 {
8187 if (temp2)
8188 delete arg2;
8189 }
8190 return resultobj;
8191 fail:
8192 {
8193 if (temp2)
8194 delete arg2;
8195 }
8196 return NULL;
8197 }
8198
8199
8200 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8201 PyObject *resultobj = 0;
8202 wxToolTip *arg1 = (wxToolTip *) 0 ;
8203 wxString result;
8204 void *argp1 = 0 ;
8205 int res1 = 0 ;
8206 PyObject *swig_obj[1] ;
8207
8208 if (!args) SWIG_fail;
8209 swig_obj[0] = args;
8210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8211 if (!SWIG_IsOK(res1)) {
8212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8213 }
8214 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8215 {
8216 PyThreadState* __tstate = wxPyBeginAllowThreads();
8217 result = (arg1)->GetTip();
8218 wxPyEndAllowThreads(__tstate);
8219 if (PyErr_Occurred()) SWIG_fail;
8220 }
8221 {
8222 #if wxUSE_UNICODE
8223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8224 #else
8225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8226 #endif
8227 }
8228 return resultobj;
8229 fail:
8230 return NULL;
8231 }
8232
8233
8234 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8235 PyObject *resultobj = 0;
8236 wxToolTip *arg1 = (wxToolTip *) 0 ;
8237 wxWindow *result = 0 ;
8238 void *argp1 = 0 ;
8239 int res1 = 0 ;
8240 PyObject *swig_obj[1] ;
8241
8242 if (!args) SWIG_fail;
8243 swig_obj[0] = args;
8244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8245 if (!SWIG_IsOK(res1)) {
8246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8247 }
8248 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8249 {
8250 PyThreadState* __tstate = wxPyBeginAllowThreads();
8251 result = (wxWindow *)(arg1)->GetWindow();
8252 wxPyEndAllowThreads(__tstate);
8253 if (PyErr_Occurred()) SWIG_fail;
8254 }
8255 {
8256 resultobj = wxPyMake_wxObject(result, 0);
8257 }
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj = 0;
8266 bool arg1 ;
8267 bool val1 ;
8268 int ecode1 = 0 ;
8269 PyObject * obj0 = 0 ;
8270 char * kwnames[] = {
8271 (char *) "flag", NULL
8272 };
8273
8274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8275 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8276 if (!SWIG_IsOK(ecode1)) {
8277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8278 }
8279 arg1 = static_cast< bool >(val1);
8280 {
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 wxToolTip::Enable(arg1);
8283 wxPyEndAllowThreads(__tstate);
8284 if (PyErr_Occurred()) SWIG_fail;
8285 }
8286 resultobj = SWIG_Py_Void();
8287 return resultobj;
8288 fail:
8289 return NULL;
8290 }
8291
8292
8293 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8294 PyObject *resultobj = 0;
8295 long arg1 ;
8296 long val1 ;
8297 int ecode1 = 0 ;
8298 PyObject * obj0 = 0 ;
8299 char * kwnames[] = {
8300 (char *) "milliseconds", NULL
8301 };
8302
8303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8304 ecode1 = SWIG_AsVal_long(obj0, &val1);
8305 if (!SWIG_IsOK(ecode1)) {
8306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8307 }
8308 arg1 = static_cast< long >(val1);
8309 {
8310 PyThreadState* __tstate = wxPyBeginAllowThreads();
8311 wxToolTip::SetDelay(arg1);
8312 wxPyEndAllowThreads(__tstate);
8313 if (PyErr_Occurred()) SWIG_fail;
8314 }
8315 resultobj = SWIG_Py_Void();
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8323 PyObject *obj;
8324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8325 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8326 return SWIG_Py_Void();
8327 }
8328
8329 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8330 return SWIG_Python_InitShadowInstance(args);
8331 }
8332
8333 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8334 PyObject *resultobj = 0;
8335 wxWindow *arg1 = (wxWindow *) 0 ;
8336 wxSize *arg2 = 0 ;
8337 wxCaret *result = 0 ;
8338 void *argp1 = 0 ;
8339 int res1 = 0 ;
8340 wxSize temp2 ;
8341 PyObject * obj0 = 0 ;
8342 PyObject * obj1 = 0 ;
8343 char * kwnames[] = {
8344 (char *) "window",(char *) "size", NULL
8345 };
8346
8347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8349 if (!SWIG_IsOK(res1)) {
8350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8351 }
8352 arg1 = reinterpret_cast< wxWindow * >(argp1);
8353 {
8354 arg2 = &temp2;
8355 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8356 }
8357 {
8358 if (!wxPyCheckForApp()) SWIG_fail;
8359 PyThreadState* __tstate = wxPyBeginAllowThreads();
8360 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8361 wxPyEndAllowThreads(__tstate);
8362 if (PyErr_Occurred()) SWIG_fail;
8363 }
8364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8365 return resultobj;
8366 fail:
8367 return NULL;
8368 }
8369
8370
8371 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8372 PyObject *resultobj = 0;
8373 wxCaret *arg1 = (wxCaret *) 0 ;
8374 void *argp1 = 0 ;
8375 int res1 = 0 ;
8376 PyObject *swig_obj[1] ;
8377
8378 if (!args) SWIG_fail;
8379 swig_obj[0] = args;
8380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8381 if (!SWIG_IsOK(res1)) {
8382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8383 }
8384 arg1 = reinterpret_cast< wxCaret * >(argp1);
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 delete arg1;
8388
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 resultobj = SWIG_Py_Void();
8393 return resultobj;
8394 fail:
8395 return NULL;
8396 }
8397
8398
8399 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8400 PyObject *resultobj = 0;
8401 wxCaret *arg1 = (wxCaret *) 0 ;
8402 void *argp1 = 0 ;
8403 int res1 = 0 ;
8404 PyObject *swig_obj[1] ;
8405
8406 if (!args) SWIG_fail;
8407 swig_obj[0] = args;
8408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8409 if (!SWIG_IsOK(res1)) {
8410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8411 }
8412 arg1 = reinterpret_cast< wxCaret * >(argp1);
8413 {
8414 PyThreadState* __tstate = wxPyBeginAllowThreads();
8415 wxCaret_Destroy(arg1);
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 resultobj = SWIG_Py_Void();
8420 return resultobj;
8421 fail:
8422 return NULL;
8423 }
8424
8425
8426 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8427 PyObject *resultobj = 0;
8428 wxCaret *arg1 = (wxCaret *) 0 ;
8429 bool result;
8430 void *argp1 = 0 ;
8431 int res1 = 0 ;
8432 PyObject *swig_obj[1] ;
8433
8434 if (!args) SWIG_fail;
8435 swig_obj[0] = args;
8436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8437 if (!SWIG_IsOK(res1)) {
8438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8439 }
8440 arg1 = reinterpret_cast< wxCaret * >(argp1);
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 result = (bool)(arg1)->IsOk();
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 {
8448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8449 }
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8457 PyObject *resultobj = 0;
8458 wxCaret *arg1 = (wxCaret *) 0 ;
8459 bool result;
8460 void *argp1 = 0 ;
8461 int res1 = 0 ;
8462 PyObject *swig_obj[1] ;
8463
8464 if (!args) SWIG_fail;
8465 swig_obj[0] = args;
8466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8467 if (!SWIG_IsOK(res1)) {
8468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8469 }
8470 arg1 = reinterpret_cast< wxCaret * >(argp1);
8471 {
8472 PyThreadState* __tstate = wxPyBeginAllowThreads();
8473 result = (bool)(arg1)->IsVisible();
8474 wxPyEndAllowThreads(__tstate);
8475 if (PyErr_Occurred()) SWIG_fail;
8476 }
8477 {
8478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8479 }
8480 return resultobj;
8481 fail:
8482 return NULL;
8483 }
8484
8485
8486 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8487 PyObject *resultobj = 0;
8488 wxCaret *arg1 = (wxCaret *) 0 ;
8489 wxPoint result;
8490 void *argp1 = 0 ;
8491 int res1 = 0 ;
8492 PyObject *swig_obj[1] ;
8493
8494 if (!args) SWIG_fail;
8495 swig_obj[0] = args;
8496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8497 if (!SWIG_IsOK(res1)) {
8498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8499 }
8500 arg1 = reinterpret_cast< wxCaret * >(argp1);
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 result = (arg1)->GetPosition();
8504 wxPyEndAllowThreads(__tstate);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8508 return resultobj;
8509 fail:
8510 return NULL;
8511 }
8512
8513
8514 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8515 PyObject *resultobj = 0;
8516 wxCaret *arg1 = (wxCaret *) 0 ;
8517 int *arg2 = (int *) 0 ;
8518 int *arg3 = (int *) 0 ;
8519 void *argp1 = 0 ;
8520 int res1 = 0 ;
8521 int temp2 ;
8522 int res2 = SWIG_TMPOBJ ;
8523 int temp3 ;
8524 int res3 = SWIG_TMPOBJ ;
8525 PyObject *swig_obj[1] ;
8526
8527 arg2 = &temp2;
8528 arg3 = &temp3;
8529 if (!args) SWIG_fail;
8530 swig_obj[0] = args;
8531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8532 if (!SWIG_IsOK(res1)) {
8533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8534 }
8535 arg1 = reinterpret_cast< wxCaret * >(argp1);
8536 {
8537 PyThreadState* __tstate = wxPyBeginAllowThreads();
8538 (arg1)->GetPosition(arg2,arg3);
8539 wxPyEndAllowThreads(__tstate);
8540 if (PyErr_Occurred()) SWIG_fail;
8541 }
8542 resultobj = SWIG_Py_Void();
8543 if (SWIG_IsTmpObj(res2)) {
8544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8545 } else {
8546 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8548 }
8549 if (SWIG_IsTmpObj(res3)) {
8550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8551 } else {
8552 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8554 }
8555 return resultobj;
8556 fail:
8557 return NULL;
8558 }
8559
8560
8561 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8562 PyObject *resultobj = 0;
8563 wxCaret *arg1 = (wxCaret *) 0 ;
8564 wxSize result;
8565 void *argp1 = 0 ;
8566 int res1 = 0 ;
8567 PyObject *swig_obj[1] ;
8568
8569 if (!args) SWIG_fail;
8570 swig_obj[0] = args;
8571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8572 if (!SWIG_IsOK(res1)) {
8573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8574 }
8575 arg1 = reinterpret_cast< wxCaret * >(argp1);
8576 {
8577 PyThreadState* __tstate = wxPyBeginAllowThreads();
8578 result = (arg1)->GetSize();
8579 wxPyEndAllowThreads(__tstate);
8580 if (PyErr_Occurred()) SWIG_fail;
8581 }
8582 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8583 return resultobj;
8584 fail:
8585 return NULL;
8586 }
8587
8588
8589 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8590 PyObject *resultobj = 0;
8591 wxCaret *arg1 = (wxCaret *) 0 ;
8592 int *arg2 = (int *) 0 ;
8593 int *arg3 = (int *) 0 ;
8594 void *argp1 = 0 ;
8595 int res1 = 0 ;
8596 int temp2 ;
8597 int res2 = SWIG_TMPOBJ ;
8598 int temp3 ;
8599 int res3 = SWIG_TMPOBJ ;
8600 PyObject *swig_obj[1] ;
8601
8602 arg2 = &temp2;
8603 arg3 = &temp3;
8604 if (!args) SWIG_fail;
8605 swig_obj[0] = args;
8606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8607 if (!SWIG_IsOK(res1)) {
8608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8609 }
8610 arg1 = reinterpret_cast< wxCaret * >(argp1);
8611 {
8612 PyThreadState* __tstate = wxPyBeginAllowThreads();
8613 (arg1)->GetSize(arg2,arg3);
8614 wxPyEndAllowThreads(__tstate);
8615 if (PyErr_Occurred()) SWIG_fail;
8616 }
8617 resultobj = SWIG_Py_Void();
8618 if (SWIG_IsTmpObj(res2)) {
8619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8620 } else {
8621 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8623 }
8624 if (SWIG_IsTmpObj(res3)) {
8625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8626 } else {
8627 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8629 }
8630 return resultobj;
8631 fail:
8632 return NULL;
8633 }
8634
8635
8636 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8637 PyObject *resultobj = 0;
8638 wxCaret *arg1 = (wxCaret *) 0 ;
8639 wxWindow *result = 0 ;
8640 void *argp1 = 0 ;
8641 int res1 = 0 ;
8642 PyObject *swig_obj[1] ;
8643
8644 if (!args) SWIG_fail;
8645 swig_obj[0] = args;
8646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8647 if (!SWIG_IsOK(res1)) {
8648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8649 }
8650 arg1 = reinterpret_cast< wxCaret * >(argp1);
8651 {
8652 PyThreadState* __tstate = wxPyBeginAllowThreads();
8653 result = (wxWindow *)(arg1)->GetWindow();
8654 wxPyEndAllowThreads(__tstate);
8655 if (PyErr_Occurred()) SWIG_fail;
8656 }
8657 {
8658 resultobj = wxPyMake_wxObject(result, 0);
8659 }
8660 return resultobj;
8661 fail:
8662 return NULL;
8663 }
8664
8665
8666 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8667 PyObject *resultobj = 0;
8668 wxCaret *arg1 = (wxCaret *) 0 ;
8669 int arg2 ;
8670 int arg3 ;
8671 void *argp1 = 0 ;
8672 int res1 = 0 ;
8673 int val2 ;
8674 int ecode2 = 0 ;
8675 int val3 ;
8676 int ecode3 = 0 ;
8677 PyObject * obj0 = 0 ;
8678 PyObject * obj1 = 0 ;
8679 PyObject * obj2 = 0 ;
8680 char * kwnames[] = {
8681 (char *) "self",(char *) "x",(char *) "y", NULL
8682 };
8683
8684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8686 if (!SWIG_IsOK(res1)) {
8687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8688 }
8689 arg1 = reinterpret_cast< wxCaret * >(argp1);
8690 ecode2 = SWIG_AsVal_int(obj1, &val2);
8691 if (!SWIG_IsOK(ecode2)) {
8692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8693 }
8694 arg2 = static_cast< int >(val2);
8695 ecode3 = SWIG_AsVal_int(obj2, &val3);
8696 if (!SWIG_IsOK(ecode3)) {
8697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8698 }
8699 arg3 = static_cast< int >(val3);
8700 {
8701 PyThreadState* __tstate = wxPyBeginAllowThreads();
8702 (arg1)->Move(arg2,arg3);
8703 wxPyEndAllowThreads(__tstate);
8704 if (PyErr_Occurred()) SWIG_fail;
8705 }
8706 resultobj = SWIG_Py_Void();
8707 return resultobj;
8708 fail:
8709 return NULL;
8710 }
8711
8712
8713 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8714 PyObject *resultobj = 0;
8715 wxCaret *arg1 = (wxCaret *) 0 ;
8716 wxPoint *arg2 = 0 ;
8717 void *argp1 = 0 ;
8718 int res1 = 0 ;
8719 wxPoint temp2 ;
8720 PyObject * obj0 = 0 ;
8721 PyObject * obj1 = 0 ;
8722 char * kwnames[] = {
8723 (char *) "self",(char *) "pt", NULL
8724 };
8725
8726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8728 if (!SWIG_IsOK(res1)) {
8729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8730 }
8731 arg1 = reinterpret_cast< wxCaret * >(argp1);
8732 {
8733 arg2 = &temp2;
8734 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8735 }
8736 {
8737 PyThreadState* __tstate = wxPyBeginAllowThreads();
8738 (arg1)->Move((wxPoint const &)*arg2);
8739 wxPyEndAllowThreads(__tstate);
8740 if (PyErr_Occurred()) SWIG_fail;
8741 }
8742 resultobj = SWIG_Py_Void();
8743 return resultobj;
8744 fail:
8745 return NULL;
8746 }
8747
8748
8749 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8750 PyObject *resultobj = 0;
8751 wxCaret *arg1 = (wxCaret *) 0 ;
8752 int arg2 ;
8753 int arg3 ;
8754 void *argp1 = 0 ;
8755 int res1 = 0 ;
8756 int val2 ;
8757 int ecode2 = 0 ;
8758 int val3 ;
8759 int ecode3 = 0 ;
8760 PyObject * obj0 = 0 ;
8761 PyObject * obj1 = 0 ;
8762 PyObject * obj2 = 0 ;
8763 char * kwnames[] = {
8764 (char *) "self",(char *) "width",(char *) "height", NULL
8765 };
8766
8767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8769 if (!SWIG_IsOK(res1)) {
8770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8771 }
8772 arg1 = reinterpret_cast< wxCaret * >(argp1);
8773 ecode2 = SWIG_AsVal_int(obj1, &val2);
8774 if (!SWIG_IsOK(ecode2)) {
8775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8776 }
8777 arg2 = static_cast< int >(val2);
8778 ecode3 = SWIG_AsVal_int(obj2, &val3);
8779 if (!SWIG_IsOK(ecode3)) {
8780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8781 }
8782 arg3 = static_cast< int >(val3);
8783 {
8784 PyThreadState* __tstate = wxPyBeginAllowThreads();
8785 (arg1)->SetSize(arg2,arg3);
8786 wxPyEndAllowThreads(__tstate);
8787 if (PyErr_Occurred()) SWIG_fail;
8788 }
8789 resultobj = SWIG_Py_Void();
8790 return resultobj;
8791 fail:
8792 return NULL;
8793 }
8794
8795
8796 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8797 PyObject *resultobj = 0;
8798 wxCaret *arg1 = (wxCaret *) 0 ;
8799 wxSize *arg2 = 0 ;
8800 void *argp1 = 0 ;
8801 int res1 = 0 ;
8802 wxSize temp2 ;
8803 PyObject * obj0 = 0 ;
8804 PyObject * obj1 = 0 ;
8805 char * kwnames[] = {
8806 (char *) "self",(char *) "size", NULL
8807 };
8808
8809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8811 if (!SWIG_IsOK(res1)) {
8812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8813 }
8814 arg1 = reinterpret_cast< wxCaret * >(argp1);
8815 {
8816 arg2 = &temp2;
8817 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8818 }
8819 {
8820 PyThreadState* __tstate = wxPyBeginAllowThreads();
8821 (arg1)->SetSize((wxSize const &)*arg2);
8822 wxPyEndAllowThreads(__tstate);
8823 if (PyErr_Occurred()) SWIG_fail;
8824 }
8825 resultobj = SWIG_Py_Void();
8826 return resultobj;
8827 fail:
8828 return NULL;
8829 }
8830
8831
8832 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8833 PyObject *resultobj = 0;
8834 wxCaret *arg1 = (wxCaret *) 0 ;
8835 int arg2 = (int) true ;
8836 void *argp1 = 0 ;
8837 int res1 = 0 ;
8838 int val2 ;
8839 int ecode2 = 0 ;
8840 PyObject * obj0 = 0 ;
8841 PyObject * obj1 = 0 ;
8842 char * kwnames[] = {
8843 (char *) "self",(char *) "show", NULL
8844 };
8845
8846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8848 if (!SWIG_IsOK(res1)) {
8849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8850 }
8851 arg1 = reinterpret_cast< wxCaret * >(argp1);
8852 if (obj1) {
8853 ecode2 = SWIG_AsVal_int(obj1, &val2);
8854 if (!SWIG_IsOK(ecode2)) {
8855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8856 }
8857 arg2 = static_cast< int >(val2);
8858 }
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 (arg1)->Show(arg2);
8862 wxPyEndAllowThreads(__tstate);
8863 if (PyErr_Occurred()) SWIG_fail;
8864 }
8865 resultobj = SWIG_Py_Void();
8866 return resultobj;
8867 fail:
8868 return NULL;
8869 }
8870
8871
8872 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8873 PyObject *resultobj = 0;
8874 wxCaret *arg1 = (wxCaret *) 0 ;
8875 void *argp1 = 0 ;
8876 int res1 = 0 ;
8877 PyObject *swig_obj[1] ;
8878
8879 if (!args) SWIG_fail;
8880 swig_obj[0] = args;
8881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8882 if (!SWIG_IsOK(res1)) {
8883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8884 }
8885 arg1 = reinterpret_cast< wxCaret * >(argp1);
8886 {
8887 PyThreadState* __tstate = wxPyBeginAllowThreads();
8888 (arg1)->Hide();
8889 wxPyEndAllowThreads(__tstate);
8890 if (PyErr_Occurred()) SWIG_fail;
8891 }
8892 resultobj = SWIG_Py_Void();
8893 return resultobj;
8894 fail:
8895 return NULL;
8896 }
8897
8898
8899 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8900 PyObject *resultobj = 0;
8901 int result;
8902
8903 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8904 {
8905 PyThreadState* __tstate = wxPyBeginAllowThreads();
8906 result = (int)wxCaret::GetBlinkTime();
8907 wxPyEndAllowThreads(__tstate);
8908 if (PyErr_Occurred()) SWIG_fail;
8909 }
8910 resultobj = SWIG_From_int(static_cast< int >(result));
8911 return resultobj;
8912 fail:
8913 return NULL;
8914 }
8915
8916
8917 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8918 PyObject *resultobj = 0;
8919 int arg1 ;
8920 int val1 ;
8921 int ecode1 = 0 ;
8922 PyObject * obj0 = 0 ;
8923 char * kwnames[] = {
8924 (char *) "milliseconds", NULL
8925 };
8926
8927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8928 ecode1 = SWIG_AsVal_int(obj0, &val1);
8929 if (!SWIG_IsOK(ecode1)) {
8930 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8931 }
8932 arg1 = static_cast< int >(val1);
8933 {
8934 PyThreadState* __tstate = wxPyBeginAllowThreads();
8935 wxCaret::SetBlinkTime(arg1);
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 resultobj = SWIG_Py_Void();
8940 return resultobj;
8941 fail:
8942 return NULL;
8943 }
8944
8945
8946 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8947 PyObject *obj;
8948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8949 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8950 return SWIG_Py_Void();
8951 }
8952
8953 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8954 return SWIG_Python_InitShadowInstance(args);
8955 }
8956
8957 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8958 PyObject *resultobj = 0;
8959 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8960 wxBusyCursor *result = 0 ;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject * obj0 = 0 ;
8964 char * kwnames[] = {
8965 (char *) "cursor", NULL
8966 };
8967
8968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8969 if (obj0) {
8970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8971 if (!SWIG_IsOK(res1)) {
8972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8973 }
8974 arg1 = reinterpret_cast< wxCursor * >(argp1);
8975 }
8976 {
8977 if (!wxPyCheckForApp()) SWIG_fail;
8978 PyThreadState* __tstate = wxPyBeginAllowThreads();
8979 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8980 wxPyEndAllowThreads(__tstate);
8981 if (PyErr_Occurred()) SWIG_fail;
8982 }
8983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8991 PyObject *resultobj = 0;
8992 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8993 void *argp1 = 0 ;
8994 int res1 = 0 ;
8995 PyObject *swig_obj[1] ;
8996
8997 if (!args) SWIG_fail;
8998 swig_obj[0] = args;
8999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9000 if (!SWIG_IsOK(res1)) {
9001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9002 }
9003 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9004 {
9005 PyThreadState* __tstate = wxPyBeginAllowThreads();
9006 delete arg1;
9007
9008 wxPyEndAllowThreads(__tstate);
9009 if (PyErr_Occurred()) SWIG_fail;
9010 }
9011 resultobj = SWIG_Py_Void();
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9019 PyObject *obj;
9020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9021 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9022 return SWIG_Py_Void();
9023 }
9024
9025 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9026 return SWIG_Python_InitShadowInstance(args);
9027 }
9028
9029 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9030 PyObject *resultobj = 0;
9031 wxWindow *arg1 = (wxWindow *) NULL ;
9032 wxWindowDisabler *result = 0 ;
9033 void *argp1 = 0 ;
9034 int res1 = 0 ;
9035 PyObject * obj0 = 0 ;
9036 char * kwnames[] = {
9037 (char *) "winToSkip", NULL
9038 };
9039
9040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9041 if (obj0) {
9042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9043 if (!SWIG_IsOK(res1)) {
9044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9045 }
9046 arg1 = reinterpret_cast< wxWindow * >(argp1);
9047 }
9048 {
9049 if (!wxPyCheckForApp()) SWIG_fail;
9050 PyThreadState* __tstate = wxPyBeginAllowThreads();
9051 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9056 return resultobj;
9057 fail:
9058 return NULL;
9059 }
9060
9061
9062 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9063 PyObject *resultobj = 0;
9064 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9065 void *argp1 = 0 ;
9066 int res1 = 0 ;
9067 PyObject *swig_obj[1] ;
9068
9069 if (!args) SWIG_fail;
9070 swig_obj[0] = args;
9071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9072 if (!SWIG_IsOK(res1)) {
9073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9074 }
9075 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9076 {
9077 PyThreadState* __tstate = wxPyBeginAllowThreads();
9078 delete arg1;
9079
9080 wxPyEndAllowThreads(__tstate);
9081 if (PyErr_Occurred()) SWIG_fail;
9082 }
9083 resultobj = SWIG_Py_Void();
9084 return resultobj;
9085 fail:
9086 return NULL;
9087 }
9088
9089
9090 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9091 PyObject *obj;
9092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9093 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9094 return SWIG_Py_Void();
9095 }
9096
9097 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9098 return SWIG_Python_InitShadowInstance(args);
9099 }
9100
9101 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9102 PyObject *resultobj = 0;
9103 wxString *arg1 = 0 ;
9104 wxBusyInfo *result = 0 ;
9105 bool temp1 = false ;
9106 PyObject * obj0 = 0 ;
9107 char * kwnames[] = {
9108 (char *) "message", NULL
9109 };
9110
9111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9112 {
9113 arg1 = wxString_in_helper(obj0);
9114 if (arg1 == NULL) SWIG_fail;
9115 temp1 = true;
9116 }
9117 {
9118 if (!wxPyCheckForApp()) SWIG_fail;
9119 PyThreadState* __tstate = wxPyBeginAllowThreads();
9120 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9121 wxPyEndAllowThreads(__tstate);
9122 if (PyErr_Occurred()) SWIG_fail;
9123 }
9124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9125 {
9126 if (temp1)
9127 delete arg1;
9128 }
9129 return resultobj;
9130 fail:
9131 {
9132 if (temp1)
9133 delete arg1;
9134 }
9135 return NULL;
9136 }
9137
9138
9139 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9140 PyObject *resultobj = 0;
9141 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9142 void *argp1 = 0 ;
9143 int res1 = 0 ;
9144 PyObject *swig_obj[1] ;
9145
9146 if (!args) SWIG_fail;
9147 swig_obj[0] = args;
9148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9149 if (!SWIG_IsOK(res1)) {
9150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9151 }
9152 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9153 {
9154 PyThreadState* __tstate = wxPyBeginAllowThreads();
9155 delete arg1;
9156
9157 wxPyEndAllowThreads(__tstate);
9158 if (PyErr_Occurred()) SWIG_fail;
9159 }
9160 resultobj = SWIG_Py_Void();
9161 return resultobj;
9162 fail:
9163 return NULL;
9164 }
9165
9166
9167 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9168 PyObject *obj;
9169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9170 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9171 return SWIG_Py_Void();
9172 }
9173
9174 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9175 return SWIG_Python_InitShadowInstance(args);
9176 }
9177
9178 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9179 PyObject *resultobj = 0;
9180 wxStopWatch *result = 0 ;
9181
9182 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9183 {
9184 PyThreadState* __tstate = wxPyBeginAllowThreads();
9185 result = (wxStopWatch *)new wxStopWatch();
9186 wxPyEndAllowThreads(__tstate);
9187 if (PyErr_Occurred()) SWIG_fail;
9188 }
9189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9190 return resultobj;
9191 fail:
9192 return NULL;
9193 }
9194
9195
9196 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9197 PyObject *resultobj = 0;
9198 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9199 long arg2 = (long) 0 ;
9200 void *argp1 = 0 ;
9201 int res1 = 0 ;
9202 long val2 ;
9203 int ecode2 = 0 ;
9204 PyObject * obj0 = 0 ;
9205 PyObject * obj1 = 0 ;
9206 char * kwnames[] = {
9207 (char *) "self",(char *) "t0", NULL
9208 };
9209
9210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9212 if (!SWIG_IsOK(res1)) {
9213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9214 }
9215 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9216 if (obj1) {
9217 ecode2 = SWIG_AsVal_long(obj1, &val2);
9218 if (!SWIG_IsOK(ecode2)) {
9219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9220 }
9221 arg2 = static_cast< long >(val2);
9222 }
9223 {
9224 PyThreadState* __tstate = wxPyBeginAllowThreads();
9225 (arg1)->Start(arg2);
9226 wxPyEndAllowThreads(__tstate);
9227 if (PyErr_Occurred()) SWIG_fail;
9228 }
9229 resultobj = SWIG_Py_Void();
9230 return resultobj;
9231 fail:
9232 return NULL;
9233 }
9234
9235
9236 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9237 PyObject *resultobj = 0;
9238 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9239 void *argp1 = 0 ;
9240 int res1 = 0 ;
9241 PyObject *swig_obj[1] ;
9242
9243 if (!args) SWIG_fail;
9244 swig_obj[0] = args;
9245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9246 if (!SWIG_IsOK(res1)) {
9247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9248 }
9249 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9250 {
9251 PyThreadState* __tstate = wxPyBeginAllowThreads();
9252 (arg1)->Pause();
9253 wxPyEndAllowThreads(__tstate);
9254 if (PyErr_Occurred()) SWIG_fail;
9255 }
9256 resultobj = SWIG_Py_Void();
9257 return resultobj;
9258 fail:
9259 return NULL;
9260 }
9261
9262
9263 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9264 PyObject *resultobj = 0;
9265 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9266 void *argp1 = 0 ;
9267 int res1 = 0 ;
9268 PyObject *swig_obj[1] ;
9269
9270 if (!args) SWIG_fail;
9271 swig_obj[0] = args;
9272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9273 if (!SWIG_IsOK(res1)) {
9274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9275 }
9276 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9277 {
9278 PyThreadState* __tstate = wxPyBeginAllowThreads();
9279 (arg1)->Resume();
9280 wxPyEndAllowThreads(__tstate);
9281 if (PyErr_Occurred()) SWIG_fail;
9282 }
9283 resultobj = SWIG_Py_Void();
9284 return resultobj;
9285 fail:
9286 return NULL;
9287 }
9288
9289
9290 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9291 PyObject *resultobj = 0;
9292 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9293 long result;
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, 0 | 0 );
9301 if (!SWIG_IsOK(res1)) {
9302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9303 }
9304 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = (long)((wxStopWatch const *)arg1)->Time();
9308 wxPyEndAllowThreads(__tstate);
9309 if (PyErr_Occurred()) SWIG_fail;
9310 }
9311 resultobj = SWIG_From_long(static_cast< long >(result));
9312 return resultobj;
9313 fail:
9314 return NULL;
9315 }
9316
9317
9318 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9319 PyObject *obj;
9320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9321 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9322 return SWIG_Py_Void();
9323 }
9324
9325 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9326 return SWIG_Python_InitShadowInstance(args);
9327 }
9328
9329 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9330 PyObject *resultobj = 0;
9331 int arg1 = (int) 9 ;
9332 int arg2 = (int) wxID_FILE1 ;
9333 wxFileHistory *result = 0 ;
9334 int val1 ;
9335 int ecode1 = 0 ;
9336 int val2 ;
9337 int ecode2 = 0 ;
9338 PyObject * obj0 = 0 ;
9339 PyObject * obj1 = 0 ;
9340 char * kwnames[] = {
9341 (char *) "maxFiles",(char *) "idBase", NULL
9342 };
9343
9344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9345 if (obj0) {
9346 ecode1 = SWIG_AsVal_int(obj0, &val1);
9347 if (!SWIG_IsOK(ecode1)) {
9348 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9349 }
9350 arg1 = static_cast< int >(val1);
9351 }
9352 if (obj1) {
9353 ecode2 = SWIG_AsVal_int(obj1, &val2);
9354 if (!SWIG_IsOK(ecode2)) {
9355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9356 }
9357 arg2 = static_cast< int >(val2);
9358 }
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9373 PyObject *resultobj = 0;
9374 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9375 void *argp1 = 0 ;
9376 int res1 = 0 ;
9377 PyObject *swig_obj[1] ;
9378
9379 if (!args) SWIG_fail;
9380 swig_obj[0] = args;
9381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9382 if (!SWIG_IsOK(res1)) {
9383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9384 }
9385 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9386 {
9387 PyThreadState* __tstate = wxPyBeginAllowThreads();
9388 delete arg1;
9389
9390 wxPyEndAllowThreads(__tstate);
9391 if (PyErr_Occurred()) SWIG_fail;
9392 }
9393 resultobj = SWIG_Py_Void();
9394 return resultobj;
9395 fail:
9396 return NULL;
9397 }
9398
9399
9400 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9401 PyObject *resultobj = 0;
9402 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9403 wxString *arg2 = 0 ;
9404 void *argp1 = 0 ;
9405 int res1 = 0 ;
9406 bool temp2 = false ;
9407 PyObject * obj0 = 0 ;
9408 PyObject * obj1 = 0 ;
9409 char * kwnames[] = {
9410 (char *) "self",(char *) "file", NULL
9411 };
9412
9413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9415 if (!SWIG_IsOK(res1)) {
9416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9417 }
9418 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9419 {
9420 arg2 = wxString_in_helper(obj1);
9421 if (arg2 == NULL) SWIG_fail;
9422 temp2 = true;
9423 }
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 (arg1)->AddFileToHistory((wxString const &)*arg2);
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 resultobj = SWIG_Py_Void();
9431 {
9432 if (temp2)
9433 delete arg2;
9434 }
9435 return resultobj;
9436 fail:
9437 {
9438 if (temp2)
9439 delete arg2;
9440 }
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9448 int arg2 ;
9449 void *argp1 = 0 ;
9450 int res1 = 0 ;
9451 int val2 ;
9452 int ecode2 = 0 ;
9453 PyObject * obj0 = 0 ;
9454 PyObject * obj1 = 0 ;
9455 char * kwnames[] = {
9456 (char *) "self",(char *) "i", NULL
9457 };
9458
9459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9461 if (!SWIG_IsOK(res1)) {
9462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9463 }
9464 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9465 ecode2 = SWIG_AsVal_int(obj1, &val2);
9466 if (!SWIG_IsOK(ecode2)) {
9467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9468 }
9469 arg2 = static_cast< int >(val2);
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 (arg1)->RemoveFileFromHistory(arg2);
9473 wxPyEndAllowThreads(__tstate);
9474 if (PyErr_Occurred()) SWIG_fail;
9475 }
9476 resultobj = SWIG_Py_Void();
9477 return resultobj;
9478 fail:
9479 return NULL;
9480 }
9481
9482
9483 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9484 PyObject *resultobj = 0;
9485 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9486 int result;
9487 void *argp1 = 0 ;
9488 int res1 = 0 ;
9489 PyObject *swig_obj[1] ;
9490
9491 if (!args) SWIG_fail;
9492 swig_obj[0] = args;
9493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9494 if (!SWIG_IsOK(res1)) {
9495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9496 }
9497 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9498 {
9499 PyThreadState* __tstate = wxPyBeginAllowThreads();
9500 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9501 wxPyEndAllowThreads(__tstate);
9502 if (PyErr_Occurred()) SWIG_fail;
9503 }
9504 resultobj = SWIG_From_int(static_cast< int >(result));
9505 return resultobj;
9506 fail:
9507 return NULL;
9508 }
9509
9510
9511 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9512 PyObject *resultobj = 0;
9513 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9514 wxMenu *arg2 = (wxMenu *) 0 ;
9515 void *argp1 = 0 ;
9516 int res1 = 0 ;
9517 void *argp2 = 0 ;
9518 int res2 = 0 ;
9519 PyObject * obj0 = 0 ;
9520 PyObject * obj1 = 0 ;
9521 char * kwnames[] = {
9522 (char *) "self",(char *) "menu", NULL
9523 };
9524
9525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9527 if (!SWIG_IsOK(res1)) {
9528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9529 }
9530 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9531 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9532 if (!SWIG_IsOK(res2)) {
9533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9534 }
9535 arg2 = reinterpret_cast< wxMenu * >(argp2);
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 (arg1)->UseMenu(arg2);
9539 wxPyEndAllowThreads(__tstate);
9540 if (PyErr_Occurred()) SWIG_fail;
9541 }
9542 resultobj = SWIG_Py_Void();
9543 return resultobj;
9544 fail:
9545 return NULL;
9546 }
9547
9548
9549 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9550 PyObject *resultobj = 0;
9551 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9552 wxMenu *arg2 = (wxMenu *) 0 ;
9553 void *argp1 = 0 ;
9554 int res1 = 0 ;
9555 void *argp2 = 0 ;
9556 int res2 = 0 ;
9557 PyObject * obj0 = 0 ;
9558 PyObject * obj1 = 0 ;
9559 char * kwnames[] = {
9560 (char *) "self",(char *) "menu", NULL
9561 };
9562
9563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9565 if (!SWIG_IsOK(res1)) {
9566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9567 }
9568 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9570 if (!SWIG_IsOK(res2)) {
9571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9572 }
9573 arg2 = reinterpret_cast< wxMenu * >(argp2);
9574 {
9575 PyThreadState* __tstate = wxPyBeginAllowThreads();
9576 (arg1)->RemoveMenu(arg2);
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 resultobj = SWIG_Py_Void();
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj = 0;
9589 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9590 wxConfigBase *arg2 = 0 ;
9591 void *argp1 = 0 ;
9592 int res1 = 0 ;
9593 void *argp2 = 0 ;
9594 int res2 = 0 ;
9595 PyObject * obj0 = 0 ;
9596 PyObject * obj1 = 0 ;
9597 char * kwnames[] = {
9598 (char *) "self",(char *) "config", NULL
9599 };
9600
9601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9603 if (!SWIG_IsOK(res1)) {
9604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9605 }
9606 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9607 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9608 if (!SWIG_IsOK(res2)) {
9609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9610 }
9611 if (!argp2) {
9612 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9613 }
9614 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9615 {
9616 PyThreadState* __tstate = wxPyBeginAllowThreads();
9617 (arg1)->Load(*arg2);
9618 wxPyEndAllowThreads(__tstate);
9619 if (PyErr_Occurred()) SWIG_fail;
9620 }
9621 resultobj = SWIG_Py_Void();
9622 return resultobj;
9623 fail:
9624 return NULL;
9625 }
9626
9627
9628 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9629 PyObject *resultobj = 0;
9630 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9631 wxConfigBase *arg2 = 0 ;
9632 void *argp1 = 0 ;
9633 int res1 = 0 ;
9634 void *argp2 = 0 ;
9635 int res2 = 0 ;
9636 PyObject * obj0 = 0 ;
9637 PyObject * obj1 = 0 ;
9638 char * kwnames[] = {
9639 (char *) "self",(char *) "config", NULL
9640 };
9641
9642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9644 if (!SWIG_IsOK(res1)) {
9645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9646 }
9647 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9648 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9649 if (!SWIG_IsOK(res2)) {
9650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9651 }
9652 if (!argp2) {
9653 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9654 }
9655 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9656 {
9657 PyThreadState* __tstate = wxPyBeginAllowThreads();
9658 (arg1)->Save(*arg2);
9659 wxPyEndAllowThreads(__tstate);
9660 if (PyErr_Occurred()) SWIG_fail;
9661 }
9662 resultobj = SWIG_Py_Void();
9663 return resultobj;
9664 fail:
9665 return NULL;
9666 }
9667
9668
9669 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9670 PyObject *resultobj = 0;
9671 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9672 void *argp1 = 0 ;
9673 int res1 = 0 ;
9674 PyObject *swig_obj[1] ;
9675
9676 if (!args) SWIG_fail;
9677 swig_obj[0] = args;
9678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9679 if (!SWIG_IsOK(res1)) {
9680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9681 }
9682 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9683 {
9684 PyThreadState* __tstate = wxPyBeginAllowThreads();
9685 (arg1)->AddFilesToMenu();
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 resultobj = SWIG_Py_Void();
9690 return resultobj;
9691 fail:
9692 return NULL;
9693 }
9694
9695
9696 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9697 PyObject *resultobj = 0;
9698 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9699 wxMenu *arg2 = (wxMenu *) 0 ;
9700 void *argp1 = 0 ;
9701 int res1 = 0 ;
9702 void *argp2 = 0 ;
9703 int res2 = 0 ;
9704 PyObject * obj0 = 0 ;
9705 PyObject * obj1 = 0 ;
9706 char * kwnames[] = {
9707 (char *) "self",(char *) "menu", NULL
9708 };
9709
9710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9712 if (!SWIG_IsOK(res1)) {
9713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9714 }
9715 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9716 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9717 if (!SWIG_IsOK(res2)) {
9718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9719 }
9720 arg2 = reinterpret_cast< wxMenu * >(argp2);
9721 {
9722 PyThreadState* __tstate = wxPyBeginAllowThreads();
9723 (arg1)->AddFilesToMenu(arg2);
9724 wxPyEndAllowThreads(__tstate);
9725 if (PyErr_Occurred()) SWIG_fail;
9726 }
9727 resultobj = SWIG_Py_Void();
9728 return resultobj;
9729 fail:
9730 return NULL;
9731 }
9732
9733
9734 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9735 PyObject *resultobj = 0;
9736 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9737 int arg2 ;
9738 wxString result;
9739 void *argp1 = 0 ;
9740 int res1 = 0 ;
9741 int val2 ;
9742 int ecode2 = 0 ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 char * kwnames[] = {
9746 (char *) "self",(char *) "i", NULL
9747 };
9748
9749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9751 if (!SWIG_IsOK(res1)) {
9752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9753 }
9754 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9755 ecode2 = SWIG_AsVal_int(obj1, &val2);
9756 if (!SWIG_IsOK(ecode2)) {
9757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9758 }
9759 arg2 = static_cast< int >(val2);
9760 {
9761 PyThreadState* __tstate = wxPyBeginAllowThreads();
9762 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9763 wxPyEndAllowThreads(__tstate);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 {
9767 #if wxUSE_UNICODE
9768 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9769 #else
9770 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9771 #endif
9772 }
9773 return resultobj;
9774 fail:
9775 return NULL;
9776 }
9777
9778
9779 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9780 PyObject *resultobj = 0;
9781 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9782 int result;
9783 void *argp1 = 0 ;
9784 int res1 = 0 ;
9785 PyObject *swig_obj[1] ;
9786
9787 if (!args) SWIG_fail;
9788 swig_obj[0] = args;
9789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9790 if (!SWIG_IsOK(res1)) {
9791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9792 }
9793 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9794 {
9795 PyThreadState* __tstate = wxPyBeginAllowThreads();
9796 result = (int)((wxFileHistory const *)arg1)->GetCount();
9797 wxPyEndAllowThreads(__tstate);
9798 if (PyErr_Occurred()) SWIG_fail;
9799 }
9800 resultobj = SWIG_From_int(static_cast< int >(result));
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9808 PyObject *obj;
9809 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9810 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9811 return SWIG_Py_Void();
9812 }
9813
9814 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9815 return SWIG_Python_InitShadowInstance(args);
9816 }
9817
9818 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9819 PyObject *resultobj = 0;
9820 wxString *arg1 = 0 ;
9821 wxString const &arg2_defvalue = wxPyEmptyString ;
9822 wxString *arg2 = (wxString *) &arg2_defvalue ;
9823 wxSingleInstanceChecker *result = 0 ;
9824 bool temp1 = false ;
9825 bool temp2 = false ;
9826 PyObject * obj0 = 0 ;
9827 PyObject * obj1 = 0 ;
9828 char * kwnames[] = {
9829 (char *) "name",(char *) "path", NULL
9830 };
9831
9832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9833 {
9834 arg1 = wxString_in_helper(obj0);
9835 if (arg1 == NULL) SWIG_fail;
9836 temp1 = true;
9837 }
9838 if (obj1) {
9839 {
9840 arg2 = wxString_in_helper(obj1);
9841 if (arg2 == NULL) SWIG_fail;
9842 temp2 = true;
9843 }
9844 }
9845 {
9846 PyThreadState* __tstate = wxPyBeginAllowThreads();
9847 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9852 {
9853 if (temp1)
9854 delete arg1;
9855 }
9856 {
9857 if (temp2)
9858 delete arg2;
9859 }
9860 return resultobj;
9861 fail:
9862 {
9863 if (temp1)
9864 delete arg1;
9865 }
9866 {
9867 if (temp2)
9868 delete arg2;
9869 }
9870 return NULL;
9871 }
9872
9873
9874 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9875 PyObject *resultobj = 0;
9876 wxSingleInstanceChecker *result = 0 ;
9877
9878 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9882 wxPyEndAllowThreads(__tstate);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9893 PyObject *resultobj = 0;
9894 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9895 void *argp1 = 0 ;
9896 int res1 = 0 ;
9897 PyObject *swig_obj[1] ;
9898
9899 if (!args) SWIG_fail;
9900 swig_obj[0] = args;
9901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9902 if (!SWIG_IsOK(res1)) {
9903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9904 }
9905 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9906 {
9907 PyThreadState* __tstate = wxPyBeginAllowThreads();
9908 delete arg1;
9909
9910 wxPyEndAllowThreads(__tstate);
9911 if (PyErr_Occurred()) SWIG_fail;
9912 }
9913 resultobj = SWIG_Py_Void();
9914 return resultobj;
9915 fail:
9916 return NULL;
9917 }
9918
9919
9920 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9921 PyObject *resultobj = 0;
9922 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9923 wxString *arg2 = 0 ;
9924 wxString const &arg3_defvalue = wxPyEmptyString ;
9925 wxString *arg3 = (wxString *) &arg3_defvalue ;
9926 bool result;
9927 void *argp1 = 0 ;
9928 int res1 = 0 ;
9929 bool temp2 = false ;
9930 bool temp3 = false ;
9931 PyObject * obj0 = 0 ;
9932 PyObject * obj1 = 0 ;
9933 PyObject * obj2 = 0 ;
9934 char * kwnames[] = {
9935 (char *) "self",(char *) "name",(char *) "path", NULL
9936 };
9937
9938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9940 if (!SWIG_IsOK(res1)) {
9941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9942 }
9943 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9944 {
9945 arg2 = wxString_in_helper(obj1);
9946 if (arg2 == NULL) SWIG_fail;
9947 temp2 = true;
9948 }
9949 if (obj2) {
9950 {
9951 arg3 = wxString_in_helper(obj2);
9952 if (arg3 == NULL) SWIG_fail;
9953 temp3 = true;
9954 }
9955 }
9956 {
9957 PyThreadState* __tstate = wxPyBeginAllowThreads();
9958 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9959 wxPyEndAllowThreads(__tstate);
9960 if (PyErr_Occurred()) SWIG_fail;
9961 }
9962 {
9963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9964 }
9965 {
9966 if (temp2)
9967 delete arg2;
9968 }
9969 {
9970 if (temp3)
9971 delete arg3;
9972 }
9973 return resultobj;
9974 fail:
9975 {
9976 if (temp2)
9977 delete arg2;
9978 }
9979 {
9980 if (temp3)
9981 delete arg3;
9982 }
9983 return NULL;
9984 }
9985
9986
9987 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9988 PyObject *resultobj = 0;
9989 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9990 bool result;
9991 void *argp1 = 0 ;
9992 int res1 = 0 ;
9993 PyObject *swig_obj[1] ;
9994
9995 if (!args) SWIG_fail;
9996 swig_obj[0] = args;
9997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9998 if (!SWIG_IsOK(res1)) {
9999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10000 }
10001 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10002 {
10003 PyThreadState* __tstate = wxPyBeginAllowThreads();
10004 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 {
10009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10010 }
10011 return resultobj;
10012 fail:
10013 return NULL;
10014 }
10015
10016
10017 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10018 PyObject *obj;
10019 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10020 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10021 return SWIG_Py_Void();
10022 }
10023
10024 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10025 return SWIG_Python_InitShadowInstance(args);
10026 }
10027
10028 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10029 PyObject *resultobj = 0;
10030 wxWindow *arg1 = (wxWindow *) 0 ;
10031 wxDC *arg2 = 0 ;
10032 bool result;
10033 void *argp1 = 0 ;
10034 int res1 = 0 ;
10035 void *argp2 = 0 ;
10036 int res2 = 0 ;
10037 PyObject * obj0 = 0 ;
10038 PyObject * obj1 = 0 ;
10039 char * kwnames[] = {
10040 (char *) "window",(char *) "dc", NULL
10041 };
10042
10043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10045 if (!SWIG_IsOK(res1)) {
10046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10047 }
10048 arg1 = reinterpret_cast< wxWindow * >(argp1);
10049 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10050 if (!SWIG_IsOK(res2)) {
10051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10052 }
10053 if (!argp2) {
10054 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10055 }
10056 arg2 = reinterpret_cast< wxDC * >(argp2);
10057 {
10058 PyThreadState* __tstate = wxPyBeginAllowThreads();
10059 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10060 wxPyEndAllowThreads(__tstate);
10061 if (PyErr_Occurred()) SWIG_fail;
10062 }
10063 {
10064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10065 }
10066 return resultobj;
10067 fail:
10068 return NULL;
10069 }
10070
10071
10072 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10073 PyObject *resultobj = 0;
10074 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10075 void *argp1 = 0 ;
10076 int res1 = 0 ;
10077 PyObject *swig_obj[1] ;
10078
10079 if (!args) SWIG_fail;
10080 swig_obj[0] = args;
10081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
10082 if (!SWIG_IsOK(res1)) {
10083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10084 }
10085 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10086 {
10087 PyThreadState* __tstate = wxPyBeginAllowThreads();
10088 delete arg1;
10089
10090 wxPyEndAllowThreads(__tstate);
10091 if (PyErr_Occurred()) SWIG_fail;
10092 }
10093 resultobj = SWIG_Py_Void();
10094 return resultobj;
10095 fail:
10096 return NULL;
10097 }
10098
10099
10100 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10101 PyObject *resultobj = 0;
10102 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10103 wxString result;
10104 void *argp1 = 0 ;
10105 int res1 = 0 ;
10106 PyObject *swig_obj[1] ;
10107
10108 if (!args) SWIG_fail;
10109 swig_obj[0] = args;
10110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10111 if (!SWIG_IsOK(res1)) {
10112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10113 }
10114 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 result = (arg1)->GetTip();
10118 wxPyEndAllowThreads(__tstate);
10119 if (PyErr_Occurred()) SWIG_fail;
10120 }
10121 {
10122 #if wxUSE_UNICODE
10123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10124 #else
10125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10126 #endif
10127 }
10128 return resultobj;
10129 fail:
10130 return NULL;
10131 }
10132
10133
10134 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10135 PyObject *resultobj = 0;
10136 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10137 size_t result;
10138 void *argp1 = 0 ;
10139 int res1 = 0 ;
10140 PyObject *swig_obj[1] ;
10141
10142 if (!args) SWIG_fail;
10143 swig_obj[0] = args;
10144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10145 if (!SWIG_IsOK(res1)) {
10146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10147 }
10148 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10149 {
10150 PyThreadState* __tstate = wxPyBeginAllowThreads();
10151 result = (size_t)(arg1)->GetCurrentTip();
10152 wxPyEndAllowThreads(__tstate);
10153 if (PyErr_Occurred()) SWIG_fail;
10154 }
10155 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10156 return resultobj;
10157 fail:
10158 return NULL;
10159 }
10160
10161
10162 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10163 PyObject *resultobj = 0;
10164 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10165 wxString *arg2 = 0 ;
10166 wxString result;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 bool temp2 = false ;
10170 PyObject * obj0 = 0 ;
10171 PyObject * obj1 = 0 ;
10172 char * kwnames[] = {
10173 (char *) "self",(char *) "tip", NULL
10174 };
10175
10176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10178 if (!SWIG_IsOK(res1)) {
10179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10180 }
10181 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10182 {
10183 arg2 = wxString_in_helper(obj1);
10184 if (arg2 == NULL) SWIG_fail;
10185 temp2 = true;
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 {
10194 #if wxUSE_UNICODE
10195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10196 #else
10197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10198 #endif
10199 }
10200 {
10201 if (temp2)
10202 delete arg2;
10203 }
10204 return resultobj;
10205 fail:
10206 {
10207 if (temp2)
10208 delete arg2;
10209 }
10210 return NULL;
10211 }
10212
10213
10214 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10215 PyObject *obj;
10216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10217 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10218 return SWIG_Py_Void();
10219 }
10220
10221 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10222 PyObject *resultobj = 0;
10223 size_t arg1 ;
10224 wxPyTipProvider *result = 0 ;
10225 size_t val1 ;
10226 int ecode1 = 0 ;
10227 PyObject * obj0 = 0 ;
10228 char * kwnames[] = {
10229 (char *) "currentTip", NULL
10230 };
10231
10232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10233 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10234 if (!SWIG_IsOK(ecode1)) {
10235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10236 }
10237 arg1 = static_cast< size_t >(val1);
10238 {
10239 PyThreadState* __tstate = wxPyBeginAllowThreads();
10240 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10241 wxPyEndAllowThreads(__tstate);
10242 if (PyErr_Occurred()) SWIG_fail;
10243 }
10244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10245 return resultobj;
10246 fail:
10247 return NULL;
10248 }
10249
10250
10251 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10252 PyObject *resultobj = 0;
10253 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10254 PyObject *arg2 = (PyObject *) 0 ;
10255 PyObject *arg3 = (PyObject *) 0 ;
10256 void *argp1 = 0 ;
10257 int res1 = 0 ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 PyObject * obj2 = 0 ;
10261 char * kwnames[] = {
10262 (char *) "self",(char *) "self",(char *) "_class", NULL
10263 };
10264
10265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10267 if (!SWIG_IsOK(res1)) {
10268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10269 }
10270 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10271 arg2 = obj1;
10272 arg3 = obj2;
10273 {
10274 PyThreadState* __tstate = wxPyBeginAllowThreads();
10275 (arg1)->_setCallbackInfo(arg2,arg3);
10276 wxPyEndAllowThreads(__tstate);
10277 if (PyErr_Occurred()) SWIG_fail;
10278 }
10279 resultobj = SWIG_Py_Void();
10280 return resultobj;
10281 fail:
10282 return NULL;
10283 }
10284
10285
10286 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10287 PyObject *obj;
10288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10289 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10290 return SWIG_Py_Void();
10291 }
10292
10293 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10294 return SWIG_Python_InitShadowInstance(args);
10295 }
10296
10297 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10298 PyObject *resultobj = 0;
10299 wxWindow *arg1 = (wxWindow *) 0 ;
10300 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10301 bool arg3 = (bool) true ;
10302 bool result;
10303 void *argp1 = 0 ;
10304 int res1 = 0 ;
10305 void *argp2 = 0 ;
10306 int res2 = 0 ;
10307 bool val3 ;
10308 int ecode3 = 0 ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 PyObject * obj2 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10320 }
10321 arg1 = reinterpret_cast< wxWindow * >(argp1);
10322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10323 if (!SWIG_IsOK(res2)) {
10324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10325 }
10326 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10327 if (obj2) {
10328 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10329 if (!SWIG_IsOK(ecode3)) {
10330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10331 }
10332 arg3 = static_cast< bool >(val3);
10333 }
10334 {
10335 if (!wxPyCheckForApp()) SWIG_fail;
10336 PyThreadState* __tstate = wxPyBeginAllowThreads();
10337 result = (bool)wxShowTip(arg1,arg2,arg3);
10338 wxPyEndAllowThreads(__tstate);
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 {
10342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10343 }
10344 return resultobj;
10345 fail:
10346 return NULL;
10347 }
10348
10349
10350 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj = 0;
10352 wxString *arg1 = 0 ;
10353 size_t arg2 ;
10354 wxTipProvider *result = 0 ;
10355 bool temp1 = false ;
10356 size_t val2 ;
10357 int ecode2 = 0 ;
10358 PyObject * obj0 = 0 ;
10359 PyObject * obj1 = 0 ;
10360 char * kwnames[] = {
10361 (char *) "filename",(char *) "currentTip", NULL
10362 };
10363
10364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10365 {
10366 arg1 = wxString_in_helper(obj0);
10367 if (arg1 == NULL) SWIG_fail;
10368 temp1 = true;
10369 }
10370 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10371 if (!SWIG_IsOK(ecode2)) {
10372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10373 }
10374 arg2 = static_cast< size_t >(val2);
10375 {
10376 if (!wxPyCheckForApp()) SWIG_fail;
10377 PyThreadState* __tstate = wxPyBeginAllowThreads();
10378 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10379 wxPyEndAllowThreads(__tstate);
10380 if (PyErr_Occurred()) SWIG_fail;
10381 }
10382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10383 {
10384 if (temp1)
10385 delete arg1;
10386 }
10387 return resultobj;
10388 fail:
10389 {
10390 if (temp1)
10391 delete arg1;
10392 }
10393 return NULL;
10394 }
10395
10396
10397 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10398 PyObject *resultobj = 0;
10399 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10400 int arg2 = (int) wxID_ANY ;
10401 wxPyTimer *result = 0 ;
10402 void *argp1 = 0 ;
10403 int res1 = 0 ;
10404 int val2 ;
10405 int ecode2 = 0 ;
10406 PyObject * obj0 = 0 ;
10407 PyObject * obj1 = 0 ;
10408 char * kwnames[] = {
10409 (char *) "owner",(char *) "id", NULL
10410 };
10411
10412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10413 if (obj0) {
10414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10415 if (!SWIG_IsOK(res1)) {
10416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10417 }
10418 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10419 }
10420 if (obj1) {
10421 ecode2 = SWIG_AsVal_int(obj1, &val2);
10422 if (!SWIG_IsOK(ecode2)) {
10423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10424 }
10425 arg2 = static_cast< int >(val2);
10426 }
10427 {
10428 if (!wxPyCheckForApp()) SWIG_fail;
10429 PyThreadState* __tstate = wxPyBeginAllowThreads();
10430 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10431 wxPyEndAllowThreads(__tstate);
10432 if (PyErr_Occurred()) SWIG_fail;
10433 }
10434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10435 return resultobj;
10436 fail:
10437 return NULL;
10438 }
10439
10440
10441 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10442 PyObject *resultobj = 0;
10443 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10444 void *argp1 = 0 ;
10445 int res1 = 0 ;
10446 PyObject *swig_obj[1] ;
10447
10448 if (!args) SWIG_fail;
10449 swig_obj[0] = args;
10450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10451 if (!SWIG_IsOK(res1)) {
10452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10453 }
10454 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10455 {
10456 PyThreadState* __tstate = wxPyBeginAllowThreads();
10457 delete arg1;
10458
10459 wxPyEndAllowThreads(__tstate);
10460 if (PyErr_Occurred()) SWIG_fail;
10461 }
10462 resultobj = SWIG_Py_Void();
10463 return resultobj;
10464 fail:
10465 return NULL;
10466 }
10467
10468
10469 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10470 PyObject *resultobj = 0;
10471 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10472 PyObject *arg2 = (PyObject *) 0 ;
10473 PyObject *arg3 = (PyObject *) 0 ;
10474 int arg4 = (int) 1 ;
10475 void *argp1 = 0 ;
10476 int res1 = 0 ;
10477 int val4 ;
10478 int ecode4 = 0 ;
10479 PyObject * obj0 = 0 ;
10480 PyObject * obj1 = 0 ;
10481 PyObject * obj2 = 0 ;
10482 PyObject * obj3 = 0 ;
10483 char * kwnames[] = {
10484 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10485 };
10486
10487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10489 if (!SWIG_IsOK(res1)) {
10490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10491 }
10492 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10493 arg2 = obj1;
10494 arg3 = obj2;
10495 if (obj3) {
10496 ecode4 = SWIG_AsVal_int(obj3, &val4);
10497 if (!SWIG_IsOK(ecode4)) {
10498 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10499 }
10500 arg4 = static_cast< int >(val4);
10501 }
10502 {
10503 PyThreadState* __tstate = wxPyBeginAllowThreads();
10504 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10505 wxPyEndAllowThreads(__tstate);
10506 if (PyErr_Occurred()) SWIG_fail;
10507 }
10508 resultobj = SWIG_Py_Void();
10509 return resultobj;
10510 fail:
10511 return NULL;
10512 }
10513
10514
10515 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10516 PyObject *resultobj = 0;
10517 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10518 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10519 int arg3 = (int) wxID_ANY ;
10520 void *argp1 = 0 ;
10521 int res1 = 0 ;
10522 void *argp2 = 0 ;
10523 int res2 = 0 ;
10524 int val3 ;
10525 int ecode3 = 0 ;
10526 PyObject * obj0 = 0 ;
10527 PyObject * obj1 = 0 ;
10528 PyObject * obj2 = 0 ;
10529 char * kwnames[] = {
10530 (char *) "self",(char *) "owner",(char *) "id", NULL
10531 };
10532
10533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10535 if (!SWIG_IsOK(res1)) {
10536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10537 }
10538 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10540 if (!SWIG_IsOK(res2)) {
10541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10542 }
10543 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10544 if (obj2) {
10545 ecode3 = SWIG_AsVal_int(obj2, &val3);
10546 if (!SWIG_IsOK(ecode3)) {
10547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10548 }
10549 arg3 = static_cast< int >(val3);
10550 }
10551 {
10552 PyThreadState* __tstate = wxPyBeginAllowThreads();
10553 (arg1)->SetOwner(arg2,arg3);
10554 wxPyEndAllowThreads(__tstate);
10555 if (PyErr_Occurred()) SWIG_fail;
10556 }
10557 resultobj = SWIG_Py_Void();
10558 return resultobj;
10559 fail:
10560 return NULL;
10561 }
10562
10563
10564 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10565 PyObject *resultobj = 0;
10566 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10567 wxEvtHandler *result = 0 ;
10568 void *argp1 = 0 ;
10569 int res1 = 0 ;
10570 PyObject *swig_obj[1] ;
10571
10572 if (!args) SWIG_fail;
10573 swig_obj[0] = args;
10574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10575 if (!SWIG_IsOK(res1)) {
10576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10577 }
10578 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10579 {
10580 PyThreadState* __tstate = wxPyBeginAllowThreads();
10581 result = (wxEvtHandler *)(arg1)->GetOwner();
10582 wxPyEndAllowThreads(__tstate);
10583 if (PyErr_Occurred()) SWIG_fail;
10584 }
10585 {
10586 resultobj = wxPyMake_wxObject(result, 0);
10587 }
10588 return resultobj;
10589 fail:
10590 return NULL;
10591 }
10592
10593
10594 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10595 PyObject *resultobj = 0;
10596 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10597 int arg2 = (int) -1 ;
10598 bool arg3 = (bool) false ;
10599 bool result;
10600 void *argp1 = 0 ;
10601 int res1 = 0 ;
10602 int val2 ;
10603 int ecode2 = 0 ;
10604 bool val3 ;
10605 int ecode3 = 0 ;
10606 PyObject * obj0 = 0 ;
10607 PyObject * obj1 = 0 ;
10608 PyObject * obj2 = 0 ;
10609 char * kwnames[] = {
10610 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10611 };
10612
10613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10615 if (!SWIG_IsOK(res1)) {
10616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10617 }
10618 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10619 if (obj1) {
10620 ecode2 = SWIG_AsVal_int(obj1, &val2);
10621 if (!SWIG_IsOK(ecode2)) {
10622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10623 }
10624 arg2 = static_cast< int >(val2);
10625 }
10626 if (obj2) {
10627 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10628 if (!SWIG_IsOK(ecode3)) {
10629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10630 }
10631 arg3 = static_cast< bool >(val3);
10632 }
10633 {
10634 PyThreadState* __tstate = wxPyBeginAllowThreads();
10635 result = (bool)(arg1)->Start(arg2,arg3);
10636 wxPyEndAllowThreads(__tstate);
10637 if (PyErr_Occurred()) SWIG_fail;
10638 }
10639 {
10640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10641 }
10642 return resultobj;
10643 fail:
10644 return NULL;
10645 }
10646
10647
10648 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10649 PyObject *resultobj = 0;
10650 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10651 void *argp1 = 0 ;
10652 int res1 = 0 ;
10653 PyObject *swig_obj[1] ;
10654
10655 if (!args) SWIG_fail;
10656 swig_obj[0] = args;
10657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10658 if (!SWIG_IsOK(res1)) {
10659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10660 }
10661 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10662 {
10663 PyThreadState* __tstate = wxPyBeginAllowThreads();
10664 (arg1)->Stop();
10665 wxPyEndAllowThreads(__tstate);
10666 if (PyErr_Occurred()) SWIG_fail;
10667 }
10668 resultobj = SWIG_Py_Void();
10669 return resultobj;
10670 fail:
10671 return NULL;
10672 }
10673
10674
10675 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10676 PyObject *resultobj = 0;
10677 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10678 void *argp1 = 0 ;
10679 int res1 = 0 ;
10680 PyObject *swig_obj[1] ;
10681
10682 if (!args) SWIG_fail;
10683 swig_obj[0] = args;
10684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10685 if (!SWIG_IsOK(res1)) {
10686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10687 }
10688 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10689 {
10690 PyThreadState* __tstate = wxPyBeginAllowThreads();
10691 (arg1)->Notify();
10692 wxPyEndAllowThreads(__tstate);
10693 if (PyErr_Occurred()) SWIG_fail;
10694 }
10695 resultobj = SWIG_Py_Void();
10696 return resultobj;
10697 fail:
10698 return NULL;
10699 }
10700
10701
10702 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10703 PyObject *resultobj = 0;
10704 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10705 bool result;
10706 void *argp1 = 0 ;
10707 int res1 = 0 ;
10708 PyObject *swig_obj[1] ;
10709
10710 if (!args) SWIG_fail;
10711 swig_obj[0] = args;
10712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10713 if (!SWIG_IsOK(res1)) {
10714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10715 }
10716 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10720 wxPyEndAllowThreads(__tstate);
10721 if (PyErr_Occurred()) SWIG_fail;
10722 }
10723 {
10724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10725 }
10726 return resultobj;
10727 fail:
10728 return NULL;
10729 }
10730
10731
10732 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10733 PyObject *resultobj = 0;
10734 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10735 int result;
10736 void *argp1 = 0 ;
10737 int res1 = 0 ;
10738 PyObject *swig_obj[1] ;
10739
10740 if (!args) SWIG_fail;
10741 swig_obj[0] = args;
10742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10743 if (!SWIG_IsOK(res1)) {
10744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10745 }
10746 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10747 {
10748 PyThreadState* __tstate = wxPyBeginAllowThreads();
10749 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10750 wxPyEndAllowThreads(__tstate);
10751 if (PyErr_Occurred()) SWIG_fail;
10752 }
10753 resultobj = SWIG_From_int(static_cast< int >(result));
10754 return resultobj;
10755 fail:
10756 return NULL;
10757 }
10758
10759
10760 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10761 PyObject *resultobj = 0;
10762 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10763 int result;
10764 void *argp1 = 0 ;
10765 int res1 = 0 ;
10766 PyObject *swig_obj[1] ;
10767
10768 if (!args) SWIG_fail;
10769 swig_obj[0] = args;
10770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10771 if (!SWIG_IsOK(res1)) {
10772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10773 }
10774 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10775 {
10776 PyThreadState* __tstate = wxPyBeginAllowThreads();
10777 result = (int)((wxPyTimer const *)arg1)->GetId();
10778 wxPyEndAllowThreads(__tstate);
10779 if (PyErr_Occurred()) SWIG_fail;
10780 }
10781 resultobj = SWIG_From_int(static_cast< int >(result));
10782 return resultobj;
10783 fail:
10784 return NULL;
10785 }
10786
10787
10788 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10789 PyObject *resultobj = 0;
10790 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10791 bool result;
10792 void *argp1 = 0 ;
10793 int res1 = 0 ;
10794 PyObject *swig_obj[1] ;
10795
10796 if (!args) SWIG_fail;
10797 swig_obj[0] = args;
10798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10799 if (!SWIG_IsOK(res1)) {
10800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10801 }
10802 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10803 {
10804 PyThreadState* __tstate = wxPyBeginAllowThreads();
10805 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10806 wxPyEndAllowThreads(__tstate);
10807 if (PyErr_Occurred()) SWIG_fail;
10808 }
10809 {
10810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10811 }
10812 return resultobj;
10813 fail:
10814 return NULL;
10815 }
10816
10817
10818 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10819 PyObject *obj;
10820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10821 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10822 return SWIG_Py_Void();
10823 }
10824
10825 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10826 return SWIG_Python_InitShadowInstance(args);
10827 }
10828
10829 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10830 PyObject *resultobj = 0;
10831 int arg1 = (int) 0 ;
10832 int arg2 = (int) 0 ;
10833 wxTimerEvent *result = 0 ;
10834 int val1 ;
10835 int ecode1 = 0 ;
10836 int val2 ;
10837 int ecode2 = 0 ;
10838 PyObject * obj0 = 0 ;
10839 PyObject * obj1 = 0 ;
10840 char * kwnames[] = {
10841 (char *) "timerid",(char *) "interval", NULL
10842 };
10843
10844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10845 if (obj0) {
10846 ecode1 = SWIG_AsVal_int(obj0, &val1);
10847 if (!SWIG_IsOK(ecode1)) {
10848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10849 }
10850 arg1 = static_cast< int >(val1);
10851 }
10852 if (obj1) {
10853 ecode2 = SWIG_AsVal_int(obj1, &val2);
10854 if (!SWIG_IsOK(ecode2)) {
10855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10856 }
10857 arg2 = static_cast< int >(val2);
10858 }
10859 {
10860 PyThreadState* __tstate = wxPyBeginAllowThreads();
10861 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10862 wxPyEndAllowThreads(__tstate);
10863 if (PyErr_Occurred()) SWIG_fail;
10864 }
10865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10866 return resultobj;
10867 fail:
10868 return NULL;
10869 }
10870
10871
10872 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10873 PyObject *resultobj = 0;
10874 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10875 int result;
10876 void *argp1 = 0 ;
10877 int res1 = 0 ;
10878 PyObject *swig_obj[1] ;
10879
10880 if (!args) SWIG_fail;
10881 swig_obj[0] = args;
10882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10883 if (!SWIG_IsOK(res1)) {
10884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10885 }
10886 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10887 {
10888 PyThreadState* __tstate = wxPyBeginAllowThreads();
10889 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10890 wxPyEndAllowThreads(__tstate);
10891 if (PyErr_Occurred()) SWIG_fail;
10892 }
10893 resultobj = SWIG_From_int(static_cast< int >(result));
10894 return resultobj;
10895 fail:
10896 return NULL;
10897 }
10898
10899
10900 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10901 PyObject *obj;
10902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10903 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10904 return SWIG_Py_Void();
10905 }
10906
10907 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10908 return SWIG_Python_InitShadowInstance(args);
10909 }
10910
10911 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10912 PyObject *resultobj = 0;
10913 wxTimer *arg1 = 0 ;
10914 wxTimerRunner *result = 0 ;
10915 void *argp1 = 0 ;
10916 int res1 = 0 ;
10917
10918 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10920 if (!SWIG_IsOK(res1)) {
10921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10922 }
10923 if (!argp1) {
10924 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10925 }
10926 arg1 = reinterpret_cast< wxTimer * >(argp1);
10927 {
10928 if (!wxPyCheckForApp()) SWIG_fail;
10929 PyThreadState* __tstate = wxPyBeginAllowThreads();
10930 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10931 wxPyEndAllowThreads(__tstate);
10932 if (PyErr_Occurred()) SWIG_fail;
10933 }
10934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10935 return resultobj;
10936 fail:
10937 return NULL;
10938 }
10939
10940
10941 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10942 PyObject *resultobj = 0;
10943 wxTimer *arg1 = 0 ;
10944 int arg2 ;
10945 bool arg3 = (bool) false ;
10946 wxTimerRunner *result = 0 ;
10947 void *argp1 = 0 ;
10948 int res1 = 0 ;
10949 int val2 ;
10950 int ecode2 = 0 ;
10951 bool val3 ;
10952 int ecode3 = 0 ;
10953
10954 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10956 if (!SWIG_IsOK(res1)) {
10957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10958 }
10959 if (!argp1) {
10960 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10961 }
10962 arg1 = reinterpret_cast< wxTimer * >(argp1);
10963 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10964 if (!SWIG_IsOK(ecode2)) {
10965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10966 }
10967 arg2 = static_cast< int >(val2);
10968 if (swig_obj[2]) {
10969 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10970 if (!SWIG_IsOK(ecode3)) {
10971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10972 }
10973 arg3 = static_cast< bool >(val3);
10974 }
10975 {
10976 if (!wxPyCheckForApp()) SWIG_fail;
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10979 wxPyEndAllowThreads(__tstate);
10980 if (PyErr_Occurred()) SWIG_fail;
10981 }
10982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10983 return resultobj;
10984 fail:
10985 return NULL;
10986 }
10987
10988
10989 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10990 int argc;
10991 PyObject *argv[4];
10992
10993 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10994 --argc;
10995 if (argc == 1) {
10996 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10997 }
10998 if ((argc >= 2) && (argc <= 3)) {
10999 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
11000 }
11001
11002 fail:
11003 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11004 return NULL;
11005 }
11006
11007
11008 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11009 PyObject *resultobj = 0;
11010 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11011 void *argp1 = 0 ;
11012 int res1 = 0 ;
11013 PyObject *swig_obj[1] ;
11014
11015 if (!args) SWIG_fail;
11016 swig_obj[0] = args;
11017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11018 if (!SWIG_IsOK(res1)) {
11019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11020 }
11021 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 delete arg1;
11025
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 resultobj = SWIG_Py_Void();
11030 return resultobj;
11031 fail:
11032 return NULL;
11033 }
11034
11035
11036 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11037 PyObject *resultobj = 0;
11038 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11039 int arg2 ;
11040 bool arg3 = (bool) false ;
11041 void *argp1 = 0 ;
11042 int res1 = 0 ;
11043 int val2 ;
11044 int ecode2 = 0 ;
11045 bool val3 ;
11046 int ecode3 = 0 ;
11047 PyObject * obj0 = 0 ;
11048 PyObject * obj1 = 0 ;
11049 PyObject * obj2 = 0 ;
11050 char * kwnames[] = {
11051 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11052 };
11053
11054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11056 if (!SWIG_IsOK(res1)) {
11057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11058 }
11059 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11060 ecode2 = SWIG_AsVal_int(obj1, &val2);
11061 if (!SWIG_IsOK(ecode2)) {
11062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11063 }
11064 arg2 = static_cast< int >(val2);
11065 if (obj2) {
11066 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11067 if (!SWIG_IsOK(ecode3)) {
11068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11069 }
11070 arg3 = static_cast< bool >(val3);
11071 }
11072 {
11073 PyThreadState* __tstate = wxPyBeginAllowThreads();
11074 (arg1)->Start(arg2,arg3);
11075 wxPyEndAllowThreads(__tstate);
11076 if (PyErr_Occurred()) SWIG_fail;
11077 }
11078 resultobj = SWIG_Py_Void();
11079 return resultobj;
11080 fail:
11081 return NULL;
11082 }
11083
11084
11085 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11086 PyObject *obj;
11087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11088 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
11089 return SWIG_Py_Void();
11090 }
11091
11092 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11093 return SWIG_Python_InitShadowInstance(args);
11094 }
11095
11096 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11097 PyObject *resultobj = 0;
11098 wxLog *result = 0 ;
11099
11100 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
11101 {
11102 PyThreadState* __tstate = wxPyBeginAllowThreads();
11103 result = (wxLog *)new wxLog();
11104 wxPyEndAllowThreads(__tstate);
11105 if (PyErr_Occurred()) SWIG_fail;
11106 }
11107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
11108 return resultobj;
11109 fail:
11110 return NULL;
11111 }
11112
11113
11114 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11115 PyObject *resultobj = 0;
11116 wxLog *arg1 = (wxLog *) 0 ;
11117 void *argp1 = 0 ;
11118 int res1 = 0 ;
11119 PyObject *swig_obj[1] ;
11120
11121 if (!args) SWIG_fail;
11122 swig_obj[0] = args;
11123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11124 if (!SWIG_IsOK(res1)) {
11125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11126 }
11127 arg1 = reinterpret_cast< wxLog * >(argp1);
11128 {
11129 PyThreadState* __tstate = wxPyBeginAllowThreads();
11130 delete arg1;
11131
11132 wxPyEndAllowThreads(__tstate);
11133 if (PyErr_Occurred()) SWIG_fail;
11134 }
11135 resultobj = SWIG_Py_Void();
11136 return resultobj;
11137 fail:
11138 return NULL;
11139 }
11140
11141
11142 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11143 PyObject *resultobj = 0;
11144 bool result;
11145
11146 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11147 {
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 result = (bool)wxLog::IsEnabled();
11150 wxPyEndAllowThreads(__tstate);
11151 if (PyErr_Occurred()) SWIG_fail;
11152 }
11153 {
11154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11155 }
11156 return resultobj;
11157 fail:
11158 return NULL;
11159 }
11160
11161
11162 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11163 PyObject *resultobj = 0;
11164 bool arg1 = (bool) true ;
11165 bool result;
11166 bool val1 ;
11167 int ecode1 = 0 ;
11168 PyObject * obj0 = 0 ;
11169 char * kwnames[] = {
11170 (char *) "doIt", NULL
11171 };
11172
11173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11174 if (obj0) {
11175 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11176 if (!SWIG_IsOK(ecode1)) {
11177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11178 }
11179 arg1 = static_cast< bool >(val1);
11180 }
11181 {
11182 PyThreadState* __tstate = wxPyBeginAllowThreads();
11183 result = (bool)wxLog::EnableLogging(arg1);
11184 wxPyEndAllowThreads(__tstate);
11185 if (PyErr_Occurred()) SWIG_fail;
11186 }
11187 {
11188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11189 }
11190 return resultobj;
11191 fail:
11192 return NULL;
11193 }
11194
11195
11196 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11197 PyObject *resultobj = 0;
11198 wxLogLevel arg1 ;
11199 wxChar *arg2 = (wxChar *) 0 ;
11200 time_t arg3 ;
11201 unsigned long val1 ;
11202 int ecode1 = 0 ;
11203 void *argp2 = 0 ;
11204 int res2 = 0 ;
11205 unsigned int val3 ;
11206 int ecode3 = 0 ;
11207 PyObject * obj0 = 0 ;
11208 PyObject * obj1 = 0 ;
11209 PyObject * obj2 = 0 ;
11210 char * kwnames[] = {
11211 (char *) "level",(char *) "szString",(char *) "t", NULL
11212 };
11213
11214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11215 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11216 if (!SWIG_IsOK(ecode1)) {
11217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11218 }
11219 arg1 = static_cast< wxLogLevel >(val1);
11220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11221 if (!SWIG_IsOK(res2)) {
11222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11223 }
11224 arg2 = reinterpret_cast< wxChar * >(argp2);
11225 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11226 if (!SWIG_IsOK(ecode3)) {
11227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11228 }
11229 arg3 = static_cast< time_t >(val3);
11230 {
11231 PyThreadState* __tstate = wxPyBeginAllowThreads();
11232 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11233 wxPyEndAllowThreads(__tstate);
11234 if (PyErr_Occurred()) SWIG_fail;
11235 }
11236 resultobj = SWIG_Py_Void();
11237 return resultobj;
11238 fail:
11239 return NULL;
11240 }
11241
11242
11243 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11244 PyObject *resultobj = 0;
11245 wxLog *arg1 = (wxLog *) 0 ;
11246 void *argp1 = 0 ;
11247 int res1 = 0 ;
11248 PyObject *swig_obj[1] ;
11249
11250 if (!args) SWIG_fail;
11251 swig_obj[0] = args;
11252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11253 if (!SWIG_IsOK(res1)) {
11254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11255 }
11256 arg1 = reinterpret_cast< wxLog * >(argp1);
11257 {
11258 PyThreadState* __tstate = wxPyBeginAllowThreads();
11259 (arg1)->Flush();
11260 wxPyEndAllowThreads(__tstate);
11261 if (PyErr_Occurred()) SWIG_fail;
11262 }
11263 resultobj = SWIG_Py_Void();
11264 return resultobj;
11265 fail:
11266 return NULL;
11267 }
11268
11269
11270 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11271 PyObject *resultobj = 0;
11272
11273 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11274 {
11275 PyThreadState* __tstate = wxPyBeginAllowThreads();
11276 wxLog::FlushActive();
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 resultobj = SWIG_Py_Void();
11281 return resultobj;
11282 fail:
11283 return NULL;
11284 }
11285
11286
11287 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11288 PyObject *resultobj = 0;
11289 wxLog *result = 0 ;
11290
11291 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11292 {
11293 PyThreadState* __tstate = wxPyBeginAllowThreads();
11294 result = (wxLog *)wxLog::GetActiveTarget();
11295 wxPyEndAllowThreads(__tstate);
11296 if (PyErr_Occurred()) SWIG_fail;
11297 }
11298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11299 return resultobj;
11300 fail:
11301 return NULL;
11302 }
11303
11304
11305 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11306 PyObject *resultobj = 0;
11307 wxLog *arg1 = (wxLog *) 0 ;
11308 wxLog *result = 0 ;
11309 int res1 = 0 ;
11310 PyObject * obj0 = 0 ;
11311 char * kwnames[] = {
11312 (char *) "pLogger", NULL
11313 };
11314
11315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11316 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11317 if (!SWIG_IsOK(res1)) {
11318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11319 }
11320 {
11321 PyThreadState* __tstate = wxPyBeginAllowThreads();
11322 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11323 wxPyEndAllowThreads(__tstate);
11324 if (PyErr_Occurred()) SWIG_fail;
11325 }
11326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11327 return resultobj;
11328 fail:
11329 return NULL;
11330 }
11331
11332
11333 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11334 PyObject *resultobj = 0;
11335
11336 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11337 {
11338 PyThreadState* __tstate = wxPyBeginAllowThreads();
11339 wxLog::Suspend();
11340 wxPyEndAllowThreads(__tstate);
11341 if (PyErr_Occurred()) SWIG_fail;
11342 }
11343 resultobj = SWIG_Py_Void();
11344 return resultobj;
11345 fail:
11346 return NULL;
11347 }
11348
11349
11350 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11351 PyObject *resultobj = 0;
11352
11353 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11354 {
11355 PyThreadState* __tstate = wxPyBeginAllowThreads();
11356 wxLog::Resume();
11357 wxPyEndAllowThreads(__tstate);
11358 if (PyErr_Occurred()) SWIG_fail;
11359 }
11360 resultobj = SWIG_Py_Void();
11361 return resultobj;
11362 fail:
11363 return NULL;
11364 }
11365
11366
11367 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11368 PyObject *resultobj = 0;
11369 bool arg1 = (bool) true ;
11370 bool val1 ;
11371 int ecode1 = 0 ;
11372 PyObject * obj0 = 0 ;
11373 char * kwnames[] = {
11374 (char *) "bVerbose", NULL
11375 };
11376
11377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11378 if (obj0) {
11379 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11380 if (!SWIG_IsOK(ecode1)) {
11381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11382 }
11383 arg1 = static_cast< bool >(val1);
11384 }
11385 {
11386 PyThreadState* __tstate = wxPyBeginAllowThreads();
11387 wxLog::SetVerbose(arg1);
11388 wxPyEndAllowThreads(__tstate);
11389 if (PyErr_Occurred()) SWIG_fail;
11390 }
11391 resultobj = SWIG_Py_Void();
11392 return resultobj;
11393 fail:
11394 return NULL;
11395 }
11396
11397
11398 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11399 PyObject *resultobj = 0;
11400 wxLogLevel arg1 ;
11401 unsigned long val1 ;
11402 int ecode1 = 0 ;
11403 PyObject * obj0 = 0 ;
11404 char * kwnames[] = {
11405 (char *) "logLevel", NULL
11406 };
11407
11408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11409 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11410 if (!SWIG_IsOK(ecode1)) {
11411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11412 }
11413 arg1 = static_cast< wxLogLevel >(val1);
11414 {
11415 PyThreadState* __tstate = wxPyBeginAllowThreads();
11416 wxLog::SetLogLevel(arg1);
11417 wxPyEndAllowThreads(__tstate);
11418 if (PyErr_Occurred()) SWIG_fail;
11419 }
11420 resultobj = SWIG_Py_Void();
11421 return resultobj;
11422 fail:
11423 return NULL;
11424 }
11425
11426
11427 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11428 PyObject *resultobj = 0;
11429
11430 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11431 {
11432 PyThreadState* __tstate = wxPyBeginAllowThreads();
11433 wxLog::DontCreateOnDemand();
11434 wxPyEndAllowThreads(__tstate);
11435 if (PyErr_Occurred()) SWIG_fail;
11436 }
11437 resultobj = SWIG_Py_Void();
11438 return resultobj;
11439 fail:
11440 return NULL;
11441 }
11442
11443
11444 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11445 PyObject *resultobj = 0;
11446 wxTraceMask arg1 ;
11447 unsigned long val1 ;
11448 int ecode1 = 0 ;
11449 PyObject * obj0 = 0 ;
11450 char * kwnames[] = {
11451 (char *) "ulMask", NULL
11452 };
11453
11454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11455 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11456 if (!SWIG_IsOK(ecode1)) {
11457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11458 }
11459 arg1 = static_cast< wxTraceMask >(val1);
11460 {
11461 PyThreadState* __tstate = wxPyBeginAllowThreads();
11462 wxLog::SetTraceMask(arg1);
11463 wxPyEndAllowThreads(__tstate);
11464 if (PyErr_Occurred()) SWIG_fail;
11465 }
11466 resultobj = SWIG_Py_Void();
11467 return resultobj;
11468 fail:
11469 return NULL;
11470 }
11471
11472
11473 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11474 PyObject *resultobj = 0;
11475 wxString *arg1 = 0 ;
11476 bool temp1 = false ;
11477 PyObject * obj0 = 0 ;
11478 char * kwnames[] = {
11479 (char *) "str", NULL
11480 };
11481
11482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11483 {
11484 arg1 = wxString_in_helper(obj0);
11485 if (arg1 == NULL) SWIG_fail;
11486 temp1 = true;
11487 }
11488 {
11489 PyThreadState* __tstate = wxPyBeginAllowThreads();
11490 wxLog::AddTraceMask((wxString const &)*arg1);
11491 wxPyEndAllowThreads(__tstate);
11492 if (PyErr_Occurred()) SWIG_fail;
11493 }
11494 resultobj = SWIG_Py_Void();
11495 {
11496 if (temp1)
11497 delete arg1;
11498 }
11499 return resultobj;
11500 fail:
11501 {
11502 if (temp1)
11503 delete arg1;
11504 }
11505 return NULL;
11506 }
11507
11508
11509 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11510 PyObject *resultobj = 0;
11511 wxString *arg1 = 0 ;
11512 bool temp1 = false ;
11513 PyObject * obj0 = 0 ;
11514 char * kwnames[] = {
11515 (char *) "str", NULL
11516 };
11517
11518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11519 {
11520 arg1 = wxString_in_helper(obj0);
11521 if (arg1 == NULL) SWIG_fail;
11522 temp1 = true;
11523 }
11524 {
11525 PyThreadState* __tstate = wxPyBeginAllowThreads();
11526 wxLog::RemoveTraceMask((wxString const &)*arg1);
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 resultobj = SWIG_Py_Void();
11531 {
11532 if (temp1)
11533 delete arg1;
11534 }
11535 return resultobj;
11536 fail:
11537 {
11538 if (temp1)
11539 delete arg1;
11540 }
11541 return NULL;
11542 }
11543
11544
11545 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11546 PyObject *resultobj = 0;
11547
11548 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11549 {
11550 PyThreadState* __tstate = wxPyBeginAllowThreads();
11551 wxLog::ClearTraceMasks();
11552 wxPyEndAllowThreads(__tstate);
11553 if (PyErr_Occurred()) SWIG_fail;
11554 }
11555 resultobj = SWIG_Py_Void();
11556 return resultobj;
11557 fail:
11558 return NULL;
11559 }
11560
11561
11562 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11563 PyObject *resultobj = 0;
11564 wxArrayString *result = 0 ;
11565
11566 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11567 {
11568 PyThreadState* __tstate = wxPyBeginAllowThreads();
11569 {
11570 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11571 result = (wxArrayString *) &_result_ref;
11572 }
11573 wxPyEndAllowThreads(__tstate);
11574 if (PyErr_Occurred()) SWIG_fail;
11575 }
11576 {
11577 resultobj = wxArrayString2PyList_helper(*result);
11578 }
11579 return resultobj;
11580 fail:
11581 return NULL;
11582 }
11583
11584
11585 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11586 PyObject *resultobj = 0;
11587 wxChar *arg1 = (wxChar *) 0 ;
11588 void *argp1 = 0 ;
11589 int res1 = 0 ;
11590 PyObject * obj0 = 0 ;
11591 char * kwnames[] = {
11592 (char *) "ts", NULL
11593 };
11594
11595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11597 if (!SWIG_IsOK(res1)) {
11598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11599 }
11600 arg1 = reinterpret_cast< wxChar * >(argp1);
11601 {
11602 PyThreadState* __tstate = wxPyBeginAllowThreads();
11603 wxLog::SetTimestamp((wxChar const *)arg1);
11604 wxPyEndAllowThreads(__tstate);
11605 if (PyErr_Occurred()) SWIG_fail;
11606 }
11607 resultobj = SWIG_Py_Void();
11608 return resultobj;
11609 fail:
11610 return NULL;
11611 }
11612
11613
11614 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11615 PyObject *resultobj = 0;
11616 bool result;
11617
11618 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 result = (bool)wxLog::GetVerbose();
11622 wxPyEndAllowThreads(__tstate);
11623 if (PyErr_Occurred()) SWIG_fail;
11624 }
11625 {
11626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11627 }
11628 return resultobj;
11629 fail:
11630 return NULL;
11631 }
11632
11633
11634 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11635 PyObject *resultobj = 0;
11636 wxTraceMask result;
11637
11638 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11639 {
11640 PyThreadState* __tstate = wxPyBeginAllowThreads();
11641 result = (wxTraceMask)wxLog::GetTraceMask();
11642 wxPyEndAllowThreads(__tstate);
11643 if (PyErr_Occurred()) SWIG_fail;
11644 }
11645 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11646 return resultobj;
11647 fail:
11648 return NULL;
11649 }
11650
11651
11652 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11653 PyObject *resultobj = 0;
11654 wxChar *arg1 = (wxChar *) 0 ;
11655 bool result;
11656 void *argp1 = 0 ;
11657 int res1 = 0 ;
11658 PyObject * obj0 = 0 ;
11659 char * kwnames[] = {
11660 (char *) "mask", NULL
11661 };
11662
11663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11665 if (!SWIG_IsOK(res1)) {
11666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11667 }
11668 arg1 = reinterpret_cast< wxChar * >(argp1);
11669 {
11670 PyThreadState* __tstate = wxPyBeginAllowThreads();
11671 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11672 wxPyEndAllowThreads(__tstate);
11673 if (PyErr_Occurred()) SWIG_fail;
11674 }
11675 {
11676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11677 }
11678 return resultobj;
11679 fail:
11680 return NULL;
11681 }
11682
11683
11684 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11685 PyObject *resultobj = 0;
11686 wxLogLevel result;
11687
11688 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11689 {
11690 PyThreadState* __tstate = wxPyBeginAllowThreads();
11691 result = (wxLogLevel)wxLog::GetLogLevel();
11692 wxPyEndAllowThreads(__tstate);
11693 if (PyErr_Occurred()) SWIG_fail;
11694 }
11695 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11696 return resultobj;
11697 fail:
11698 return NULL;
11699 }
11700
11701
11702 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11703 PyObject *resultobj = 0;
11704 wxChar *result = 0 ;
11705
11706 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (wxChar *)wxLog::GetTimestamp();
11710 wxPyEndAllowThreads(__tstate);
11711 if (PyErr_Occurred()) SWIG_fail;
11712 }
11713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11714 return resultobj;
11715 fail:
11716 return NULL;
11717 }
11718
11719
11720 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11721 PyObject *resultobj = 0;
11722 wxString result;
11723
11724 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11725 {
11726 PyThreadState* __tstate = wxPyBeginAllowThreads();
11727 result = wxLog_TimeStamp();
11728 wxPyEndAllowThreads(__tstate);
11729 if (PyErr_Occurred()) SWIG_fail;
11730 }
11731 {
11732 #if wxUSE_UNICODE
11733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11734 #else
11735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11736 #endif
11737 }
11738 return resultobj;
11739 fail:
11740 return NULL;
11741 }
11742
11743
11744 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11745 PyObject *resultobj = 0;
11746 wxLog *arg1 = (wxLog *) 0 ;
11747 void *argp1 = 0 ;
11748 int res1 = 0 ;
11749 PyObject *swig_obj[1] ;
11750
11751 if (!args) SWIG_fail;
11752 swig_obj[0] = args;
11753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11754 if (!SWIG_IsOK(res1)) {
11755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11756 }
11757 arg1 = reinterpret_cast< wxLog * >(argp1);
11758 {
11759 PyThreadState* __tstate = wxPyBeginAllowThreads();
11760 wxLog_Destroy(arg1);
11761 wxPyEndAllowThreads(__tstate);
11762 if (PyErr_Occurred()) SWIG_fail;
11763 }
11764 resultobj = SWIG_Py_Void();
11765 return resultobj;
11766 fail:
11767 return NULL;
11768 }
11769
11770
11771 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11772 PyObject *obj;
11773 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11774 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11775 return SWIG_Py_Void();
11776 }
11777
11778 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11779 return SWIG_Python_InitShadowInstance(args);
11780 }
11781
11782 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11783 PyObject *resultobj = 0;
11784 wxLogStderr *result = 0 ;
11785
11786 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11787 {
11788 PyThreadState* __tstate = wxPyBeginAllowThreads();
11789 result = (wxLogStderr *)new wxLogStderr();
11790 wxPyEndAllowThreads(__tstate);
11791 if (PyErr_Occurred()) SWIG_fail;
11792 }
11793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11794 return resultobj;
11795 fail:
11796 return NULL;
11797 }
11798
11799
11800 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11801 PyObject *obj;
11802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11803 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11804 return SWIG_Py_Void();
11805 }
11806
11807 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11808 return SWIG_Python_InitShadowInstance(args);
11809 }
11810
11811 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11812 PyObject *resultobj = 0;
11813 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11814 wxLogTextCtrl *result = 0 ;
11815 void *argp1 = 0 ;
11816 int res1 = 0 ;
11817 PyObject * obj0 = 0 ;
11818 char * kwnames[] = {
11819 (char *) "pTextCtrl", NULL
11820 };
11821
11822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11824 if (!SWIG_IsOK(res1)) {
11825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11826 }
11827 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11828 {
11829 PyThreadState* __tstate = wxPyBeginAllowThreads();
11830 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11831 wxPyEndAllowThreads(__tstate);
11832 if (PyErr_Occurred()) SWIG_fail;
11833 }
11834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11835 return resultobj;
11836 fail:
11837 return NULL;
11838 }
11839
11840
11841 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11842 PyObject *obj;
11843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11844 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11845 return SWIG_Py_Void();
11846 }
11847
11848 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11849 return SWIG_Python_InitShadowInstance(args);
11850 }
11851
11852 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11853 PyObject *resultobj = 0;
11854 wxLogGui *result = 0 ;
11855
11856 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11857 {
11858 PyThreadState* __tstate = wxPyBeginAllowThreads();
11859 result = (wxLogGui *)new wxLogGui();
11860 wxPyEndAllowThreads(__tstate);
11861 if (PyErr_Occurred()) SWIG_fail;
11862 }
11863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11864 return resultobj;
11865 fail:
11866 return NULL;
11867 }
11868
11869
11870 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11871 PyObject *obj;
11872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11873 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11874 return SWIG_Py_Void();
11875 }
11876
11877 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11878 return SWIG_Python_InitShadowInstance(args);
11879 }
11880
11881 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11882 PyObject *resultobj = 0;
11883 wxFrame *arg1 = (wxFrame *) 0 ;
11884 wxString *arg2 = 0 ;
11885 bool arg3 = (bool) true ;
11886 bool arg4 = (bool) true ;
11887 wxLogWindow *result = 0 ;
11888 void *argp1 = 0 ;
11889 int res1 = 0 ;
11890 bool temp2 = false ;
11891 bool val3 ;
11892 int ecode3 = 0 ;
11893 bool val4 ;
11894 int ecode4 = 0 ;
11895 PyObject * obj0 = 0 ;
11896 PyObject * obj1 = 0 ;
11897 PyObject * obj2 = 0 ;
11898 PyObject * obj3 = 0 ;
11899 char * kwnames[] = {
11900 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11901 };
11902
11903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11905 if (!SWIG_IsOK(res1)) {
11906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11907 }
11908 arg1 = reinterpret_cast< wxFrame * >(argp1);
11909 {
11910 arg2 = wxString_in_helper(obj1);
11911 if (arg2 == NULL) SWIG_fail;
11912 temp2 = true;
11913 }
11914 if (obj2) {
11915 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11916 if (!SWIG_IsOK(ecode3)) {
11917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11918 }
11919 arg3 = static_cast< bool >(val3);
11920 }
11921 if (obj3) {
11922 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11923 if (!SWIG_IsOK(ecode4)) {
11924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11925 }
11926 arg4 = static_cast< bool >(val4);
11927 }
11928 {
11929 PyThreadState* __tstate = wxPyBeginAllowThreads();
11930 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11935 {
11936 if (temp2)
11937 delete arg2;
11938 }
11939 return resultobj;
11940 fail:
11941 {
11942 if (temp2)
11943 delete arg2;
11944 }
11945 return NULL;
11946 }
11947
11948
11949 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11950 PyObject *resultobj = 0;
11951 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11952 bool arg2 = (bool) true ;
11953 void *argp1 = 0 ;
11954 int res1 = 0 ;
11955 bool val2 ;
11956 int ecode2 = 0 ;
11957 PyObject * obj0 = 0 ;
11958 PyObject * obj1 = 0 ;
11959 char * kwnames[] = {
11960 (char *) "self",(char *) "bShow", NULL
11961 };
11962
11963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11965 if (!SWIG_IsOK(res1)) {
11966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11967 }
11968 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11969 if (obj1) {
11970 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11971 if (!SWIG_IsOK(ecode2)) {
11972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11973 }
11974 arg2 = static_cast< bool >(val2);
11975 }
11976 {
11977 PyThreadState* __tstate = wxPyBeginAllowThreads();
11978 (arg1)->Show(arg2);
11979 wxPyEndAllowThreads(__tstate);
11980 if (PyErr_Occurred()) SWIG_fail;
11981 }
11982 resultobj = SWIG_Py_Void();
11983 return resultobj;
11984 fail:
11985 return NULL;
11986 }
11987
11988
11989 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11990 PyObject *resultobj = 0;
11991 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11992 wxFrame *result = 0 ;
11993 void *argp1 = 0 ;
11994 int res1 = 0 ;
11995 PyObject *swig_obj[1] ;
11996
11997 if (!args) SWIG_fail;
11998 swig_obj[0] = args;
11999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12000 if (!SWIG_IsOK(res1)) {
12001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12002 }
12003 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12004 {
12005 PyThreadState* __tstate = wxPyBeginAllowThreads();
12006 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12007 wxPyEndAllowThreads(__tstate);
12008 if (PyErr_Occurred()) SWIG_fail;
12009 }
12010 {
12011 resultobj = wxPyMake_wxObject(result, (bool)0);
12012 }
12013 return resultobj;
12014 fail:
12015 return NULL;
12016 }
12017
12018
12019 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12020 PyObject *resultobj = 0;
12021 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12022 wxLog *result = 0 ;
12023 void *argp1 = 0 ;
12024 int res1 = 0 ;
12025 PyObject *swig_obj[1] ;
12026
12027 if (!args) SWIG_fail;
12028 swig_obj[0] = args;
12029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12030 if (!SWIG_IsOK(res1)) {
12031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12032 }
12033 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12034 {
12035 PyThreadState* __tstate = wxPyBeginAllowThreads();
12036 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12041 return resultobj;
12042 fail:
12043 return NULL;
12044 }
12045
12046
12047 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12048 PyObject *resultobj = 0;
12049 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12050 bool result;
12051 void *argp1 = 0 ;
12052 int res1 = 0 ;
12053 PyObject *swig_obj[1] ;
12054
12055 if (!args) SWIG_fail;
12056 swig_obj[0] = args;
12057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12058 if (!SWIG_IsOK(res1)) {
12059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12060 }
12061 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12062 {
12063 PyThreadState* __tstate = wxPyBeginAllowThreads();
12064 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
12065 wxPyEndAllowThreads(__tstate);
12066 if (PyErr_Occurred()) SWIG_fail;
12067 }
12068 {
12069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12070 }
12071 return resultobj;
12072 fail:
12073 return NULL;
12074 }
12075
12076
12077 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12078 PyObject *resultobj = 0;
12079 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12080 bool arg2 ;
12081 void *argp1 = 0 ;
12082 int res1 = 0 ;
12083 bool val2 ;
12084 int ecode2 = 0 ;
12085 PyObject * obj0 = 0 ;
12086 PyObject * obj1 = 0 ;
12087 char * kwnames[] = {
12088 (char *) "self",(char *) "bDoPass", NULL
12089 };
12090
12091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12093 if (!SWIG_IsOK(res1)) {
12094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12095 }
12096 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12097 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12098 if (!SWIG_IsOK(ecode2)) {
12099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12100 }
12101 arg2 = static_cast< bool >(val2);
12102 {
12103 PyThreadState* __tstate = wxPyBeginAllowThreads();
12104 (arg1)->PassMessages(arg2);
12105 wxPyEndAllowThreads(__tstate);
12106 if (PyErr_Occurred()) SWIG_fail;
12107 }
12108 resultobj = SWIG_Py_Void();
12109 return resultobj;
12110 fail:
12111 return NULL;
12112 }
12113
12114
12115 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12116 PyObject *obj;
12117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12118 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
12119 return SWIG_Py_Void();
12120 }
12121
12122 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12123 return SWIG_Python_InitShadowInstance(args);
12124 }
12125
12126 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12127 PyObject *resultobj = 0;
12128 wxLog *arg1 = (wxLog *) 0 ;
12129 wxLogChain *result = 0 ;
12130 void *argp1 = 0 ;
12131 int res1 = 0 ;
12132 PyObject * obj0 = 0 ;
12133 char * kwnames[] = {
12134 (char *) "logger", NULL
12135 };
12136
12137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12139 if (!SWIG_IsOK(res1)) {
12140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12141 }
12142 arg1 = reinterpret_cast< wxLog * >(argp1);
12143 {
12144 PyThreadState* __tstate = wxPyBeginAllowThreads();
12145 result = (wxLogChain *)new wxLogChain(arg1);
12146 wxPyEndAllowThreads(__tstate);
12147 if (PyErr_Occurred()) SWIG_fail;
12148 }
12149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12150 return resultobj;
12151 fail:
12152 return NULL;
12153 }
12154
12155
12156 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12157 PyObject *resultobj = 0;
12158 wxLogChain *arg1 = (wxLogChain *) 0 ;
12159 wxLog *arg2 = (wxLog *) 0 ;
12160 void *argp1 = 0 ;
12161 int res1 = 0 ;
12162 void *argp2 = 0 ;
12163 int res2 = 0 ;
12164 PyObject * obj0 = 0 ;
12165 PyObject * obj1 = 0 ;
12166 char * kwnames[] = {
12167 (char *) "self",(char *) "logger", NULL
12168 };
12169
12170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12172 if (!SWIG_IsOK(res1)) {
12173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12174 }
12175 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12176 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12177 if (!SWIG_IsOK(res2)) {
12178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12179 }
12180 arg2 = reinterpret_cast< wxLog * >(argp2);
12181 {
12182 PyThreadState* __tstate = wxPyBeginAllowThreads();
12183 (arg1)->SetLog(arg2);
12184 wxPyEndAllowThreads(__tstate);
12185 if (PyErr_Occurred()) SWIG_fail;
12186 }
12187 resultobj = SWIG_Py_Void();
12188 return resultobj;
12189 fail:
12190 return NULL;
12191 }
12192
12193
12194 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12195 PyObject *resultobj = 0;
12196 wxLogChain *arg1 = (wxLogChain *) 0 ;
12197 bool arg2 ;
12198 void *argp1 = 0 ;
12199 int res1 = 0 ;
12200 bool val2 ;
12201 int ecode2 = 0 ;
12202 PyObject * obj0 = 0 ;
12203 PyObject * obj1 = 0 ;
12204 char * kwnames[] = {
12205 (char *) "self",(char *) "bDoPass", NULL
12206 };
12207
12208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12210 if (!SWIG_IsOK(res1)) {
12211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12212 }
12213 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12214 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12215 if (!SWIG_IsOK(ecode2)) {
12216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12217 }
12218 arg2 = static_cast< bool >(val2);
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 (arg1)->PassMessages(arg2);
12222 wxPyEndAllowThreads(__tstate);
12223 if (PyErr_Occurred()) SWIG_fail;
12224 }
12225 resultobj = SWIG_Py_Void();
12226 return resultobj;
12227 fail:
12228 return NULL;
12229 }
12230
12231
12232 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12233 PyObject *resultobj = 0;
12234 wxLogChain *arg1 = (wxLogChain *) 0 ;
12235 bool result;
12236 void *argp1 = 0 ;
12237 int res1 = 0 ;
12238 PyObject *swig_obj[1] ;
12239
12240 if (!args) SWIG_fail;
12241 swig_obj[0] = args;
12242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12243 if (!SWIG_IsOK(res1)) {
12244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12245 }
12246 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12247 {
12248 PyThreadState* __tstate = wxPyBeginAllowThreads();
12249 result = (bool)(arg1)->IsPassingMessages();
12250 wxPyEndAllowThreads(__tstate);
12251 if (PyErr_Occurred()) SWIG_fail;
12252 }
12253 {
12254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12255 }
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12263 PyObject *resultobj = 0;
12264 wxLogChain *arg1 = (wxLogChain *) 0 ;
12265 wxLog *result = 0 ;
12266 void *argp1 = 0 ;
12267 int res1 = 0 ;
12268 PyObject *swig_obj[1] ;
12269
12270 if (!args) SWIG_fail;
12271 swig_obj[0] = args;
12272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12273 if (!SWIG_IsOK(res1)) {
12274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12275 }
12276 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12277 {
12278 PyThreadState* __tstate = wxPyBeginAllowThreads();
12279 result = (wxLog *)(arg1)->GetOldLog();
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12284 return resultobj;
12285 fail:
12286 return NULL;
12287 }
12288
12289
12290 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12291 PyObject *obj;
12292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12293 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12294 return SWIG_Py_Void();
12295 }
12296
12297 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12298 return SWIG_Python_InitShadowInstance(args);
12299 }
12300
12301 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12302 PyObject *resultobj = 0;
12303 wxLogBuffer *result = 0 ;
12304
12305 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12306 {
12307 PyThreadState* __tstate = wxPyBeginAllowThreads();
12308 result = (wxLogBuffer *)new wxLogBuffer();
12309 wxPyEndAllowThreads(__tstate);
12310 if (PyErr_Occurred()) SWIG_fail;
12311 }
12312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12313 return resultobj;
12314 fail:
12315 return NULL;
12316 }
12317
12318
12319 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12320 PyObject *resultobj = 0;
12321 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12322 wxString *result = 0 ;
12323 void *argp1 = 0 ;
12324 int res1 = 0 ;
12325 PyObject *swig_obj[1] ;
12326
12327 if (!args) SWIG_fail;
12328 swig_obj[0] = args;
12329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12330 if (!SWIG_IsOK(res1)) {
12331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12332 }
12333 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 {
12337 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12338 result = (wxString *) &_result_ref;
12339 }
12340 wxPyEndAllowThreads(__tstate);
12341 if (PyErr_Occurred()) SWIG_fail;
12342 }
12343 {
12344 #if wxUSE_UNICODE
12345 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12346 #else
12347 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12348 #endif
12349 }
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12357 PyObject *obj;
12358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12359 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12360 return SWIG_Py_Void();
12361 }
12362
12363 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12364 return SWIG_Python_InitShadowInstance(args);
12365 }
12366
12367 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12368 PyObject *resultobj = 0;
12369 unsigned long result;
12370
12371 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12372 {
12373 PyThreadState* __tstate = wxPyBeginAllowThreads();
12374 result = (unsigned long)wxSysErrorCode();
12375 wxPyEndAllowThreads(__tstate);
12376 if (PyErr_Occurred()) SWIG_fail;
12377 }
12378 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj = 0;
12387 unsigned long arg1 = (unsigned long) 0 ;
12388 wxString result;
12389 unsigned long val1 ;
12390 int ecode1 = 0 ;
12391 PyObject * obj0 = 0 ;
12392 char * kwnames[] = {
12393 (char *) "nErrCode", NULL
12394 };
12395
12396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12397 if (obj0) {
12398 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12399 if (!SWIG_IsOK(ecode1)) {
12400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12401 }
12402 arg1 = static_cast< unsigned long >(val1);
12403 }
12404 {
12405 PyThreadState* __tstate = wxPyBeginAllowThreads();
12406 result = wxSysErrorMsg(arg1);
12407 wxPyEndAllowThreads(__tstate);
12408 if (PyErr_Occurred()) SWIG_fail;
12409 }
12410 {
12411 #if wxUSE_UNICODE
12412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12413 #else
12414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12415 #endif
12416 }
12417 return resultobj;
12418 fail:
12419 return NULL;
12420 }
12421
12422
12423 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12424 PyObject *resultobj = 0;
12425 wxString *arg1 = 0 ;
12426 bool temp1 = false ;
12427 PyObject * obj0 = 0 ;
12428 char * kwnames[] = {
12429 (char *) "msg", NULL
12430 };
12431
12432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12433 {
12434 arg1 = wxString_in_helper(obj0);
12435 if (arg1 == NULL) SWIG_fail;
12436 temp1 = true;
12437 }
12438 {
12439 PyThreadState* __tstate = wxPyBeginAllowThreads();
12440 wxPyLogFatalError((wxString const &)*arg1);
12441 wxPyEndAllowThreads(__tstate);
12442 if (PyErr_Occurred()) SWIG_fail;
12443 }
12444 resultobj = SWIG_Py_Void();
12445 {
12446 if (temp1)
12447 delete arg1;
12448 }
12449 return resultobj;
12450 fail:
12451 {
12452 if (temp1)
12453 delete arg1;
12454 }
12455 return NULL;
12456 }
12457
12458
12459 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12460 PyObject *resultobj = 0;
12461 wxString *arg1 = 0 ;
12462 bool temp1 = false ;
12463 PyObject * obj0 = 0 ;
12464 char * kwnames[] = {
12465 (char *) "msg", NULL
12466 };
12467
12468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12469 {
12470 arg1 = wxString_in_helper(obj0);
12471 if (arg1 == NULL) SWIG_fail;
12472 temp1 = true;
12473 }
12474 {
12475 PyThreadState* __tstate = wxPyBeginAllowThreads();
12476 wxPyLogError((wxString const &)*arg1);
12477 wxPyEndAllowThreads(__tstate);
12478 if (PyErr_Occurred()) SWIG_fail;
12479 }
12480 resultobj = SWIG_Py_Void();
12481 {
12482 if (temp1)
12483 delete arg1;
12484 }
12485 return resultobj;
12486 fail:
12487 {
12488 if (temp1)
12489 delete arg1;
12490 }
12491 return NULL;
12492 }
12493
12494
12495 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12496 PyObject *resultobj = 0;
12497 wxString *arg1 = 0 ;
12498 bool temp1 = false ;
12499 PyObject * obj0 = 0 ;
12500 char * kwnames[] = {
12501 (char *) "msg", NULL
12502 };
12503
12504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12505 {
12506 arg1 = wxString_in_helper(obj0);
12507 if (arg1 == NULL) SWIG_fail;
12508 temp1 = true;
12509 }
12510 {
12511 PyThreadState* __tstate = wxPyBeginAllowThreads();
12512 wxPyLogWarning((wxString const &)*arg1);
12513 wxPyEndAllowThreads(__tstate);
12514 if (PyErr_Occurred()) SWIG_fail;
12515 }
12516 resultobj = SWIG_Py_Void();
12517 {
12518 if (temp1)
12519 delete arg1;
12520 }
12521 return resultobj;
12522 fail:
12523 {
12524 if (temp1)
12525 delete arg1;
12526 }
12527 return NULL;
12528 }
12529
12530
12531 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12532 PyObject *resultobj = 0;
12533 wxString *arg1 = 0 ;
12534 bool temp1 = false ;
12535 PyObject * obj0 = 0 ;
12536 char * kwnames[] = {
12537 (char *) "msg", NULL
12538 };
12539
12540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12541 {
12542 arg1 = wxString_in_helper(obj0);
12543 if (arg1 == NULL) SWIG_fail;
12544 temp1 = true;
12545 }
12546 {
12547 PyThreadState* __tstate = wxPyBeginAllowThreads();
12548 wxPyLogMessage((wxString const &)*arg1);
12549 wxPyEndAllowThreads(__tstate);
12550 if (PyErr_Occurred()) SWIG_fail;
12551 }
12552 resultobj = SWIG_Py_Void();
12553 {
12554 if (temp1)
12555 delete arg1;
12556 }
12557 return resultobj;
12558 fail:
12559 {
12560 if (temp1)
12561 delete arg1;
12562 }
12563 return NULL;
12564 }
12565
12566
12567 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12568 PyObject *resultobj = 0;
12569 wxString *arg1 = 0 ;
12570 bool temp1 = false ;
12571 PyObject * obj0 = 0 ;
12572 char * kwnames[] = {
12573 (char *) "msg", NULL
12574 };
12575
12576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12577 {
12578 arg1 = wxString_in_helper(obj0);
12579 if (arg1 == NULL) SWIG_fail;
12580 temp1 = true;
12581 }
12582 {
12583 PyThreadState* __tstate = wxPyBeginAllowThreads();
12584 wxPyLogInfo((wxString const &)*arg1);
12585 wxPyEndAllowThreads(__tstate);
12586 if (PyErr_Occurred()) SWIG_fail;
12587 }
12588 resultobj = SWIG_Py_Void();
12589 {
12590 if (temp1)
12591 delete arg1;
12592 }
12593 return resultobj;
12594 fail:
12595 {
12596 if (temp1)
12597 delete arg1;
12598 }
12599 return NULL;
12600 }
12601
12602
12603 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12604 PyObject *resultobj = 0;
12605 wxString *arg1 = 0 ;
12606 bool temp1 = false ;
12607 PyObject * obj0 = 0 ;
12608 char * kwnames[] = {
12609 (char *) "msg", NULL
12610 };
12611
12612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12613 {
12614 arg1 = wxString_in_helper(obj0);
12615 if (arg1 == NULL) SWIG_fail;
12616 temp1 = true;
12617 }
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 wxPyLogDebug((wxString const &)*arg1);
12621 wxPyEndAllowThreads(__tstate);
12622 if (PyErr_Occurred()) SWIG_fail;
12623 }
12624 resultobj = SWIG_Py_Void();
12625 {
12626 if (temp1)
12627 delete arg1;
12628 }
12629 return resultobj;
12630 fail:
12631 {
12632 if (temp1)
12633 delete arg1;
12634 }
12635 return NULL;
12636 }
12637
12638
12639 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj = 0;
12641 wxString *arg1 = 0 ;
12642 bool temp1 = false ;
12643 PyObject * obj0 = 0 ;
12644 char * kwnames[] = {
12645 (char *) "msg", NULL
12646 };
12647
12648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12649 {
12650 arg1 = wxString_in_helper(obj0);
12651 if (arg1 == NULL) SWIG_fail;
12652 temp1 = true;
12653 }
12654 {
12655 PyThreadState* __tstate = wxPyBeginAllowThreads();
12656 wxPyLogVerbose((wxString const &)*arg1);
12657 wxPyEndAllowThreads(__tstate);
12658 if (PyErr_Occurred()) SWIG_fail;
12659 }
12660 resultobj = SWIG_Py_Void();
12661 {
12662 if (temp1)
12663 delete arg1;
12664 }
12665 return resultobj;
12666 fail:
12667 {
12668 if (temp1)
12669 delete arg1;
12670 }
12671 return NULL;
12672 }
12673
12674
12675 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12676 PyObject *resultobj = 0;
12677 wxString *arg1 = 0 ;
12678 bool temp1 = false ;
12679 PyObject * obj0 = 0 ;
12680 char * kwnames[] = {
12681 (char *) "msg", NULL
12682 };
12683
12684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12685 {
12686 arg1 = wxString_in_helper(obj0);
12687 if (arg1 == NULL) SWIG_fail;
12688 temp1 = true;
12689 }
12690 {
12691 PyThreadState* __tstate = wxPyBeginAllowThreads();
12692 wxPyLogStatus((wxString const &)*arg1);
12693 wxPyEndAllowThreads(__tstate);
12694 if (PyErr_Occurred()) SWIG_fail;
12695 }
12696 resultobj = SWIG_Py_Void();
12697 {
12698 if (temp1)
12699 delete arg1;
12700 }
12701 return resultobj;
12702 fail:
12703 {
12704 if (temp1)
12705 delete arg1;
12706 }
12707 return NULL;
12708 }
12709
12710
12711 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12712 PyObject *resultobj = 0;
12713 wxFrame *arg1 = (wxFrame *) 0 ;
12714 wxString *arg2 = 0 ;
12715 void *argp1 = 0 ;
12716 int res1 = 0 ;
12717 bool temp2 = false ;
12718 PyObject * obj0 = 0 ;
12719 PyObject * obj1 = 0 ;
12720 char * kwnames[] = {
12721 (char *) "pFrame",(char *) "msg", NULL
12722 };
12723
12724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12726 if (!SWIG_IsOK(res1)) {
12727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12728 }
12729 arg1 = reinterpret_cast< wxFrame * >(argp1);
12730 {
12731 arg2 = wxString_in_helper(obj1);
12732 if (arg2 == NULL) SWIG_fail;
12733 temp2 = true;
12734 }
12735 {
12736 PyThreadState* __tstate = wxPyBeginAllowThreads();
12737 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12738 wxPyEndAllowThreads(__tstate);
12739 if (PyErr_Occurred()) SWIG_fail;
12740 }
12741 resultobj = SWIG_Py_Void();
12742 {
12743 if (temp2)
12744 delete arg2;
12745 }
12746 return resultobj;
12747 fail:
12748 {
12749 if (temp2)
12750 delete arg2;
12751 }
12752 return NULL;
12753 }
12754
12755
12756 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12757 PyObject *resultobj = 0;
12758 wxString *arg1 = 0 ;
12759 bool temp1 = false ;
12760 PyObject * obj0 = 0 ;
12761 char * kwnames[] = {
12762 (char *) "msg", NULL
12763 };
12764
12765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12766 {
12767 arg1 = wxString_in_helper(obj0);
12768 if (arg1 == NULL) SWIG_fail;
12769 temp1 = true;
12770 }
12771 {
12772 PyThreadState* __tstate = wxPyBeginAllowThreads();
12773 wxPyLogSysError((wxString const &)*arg1);
12774 wxPyEndAllowThreads(__tstate);
12775 if (PyErr_Occurred()) SWIG_fail;
12776 }
12777 resultobj = SWIG_Py_Void();
12778 {
12779 if (temp1)
12780 delete arg1;
12781 }
12782 return resultobj;
12783 fail:
12784 {
12785 if (temp1)
12786 delete arg1;
12787 }
12788 return NULL;
12789 }
12790
12791
12792 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12793 PyObject *resultobj = 0;
12794 unsigned long arg1 ;
12795 wxString *arg2 = 0 ;
12796 unsigned long val1 ;
12797 int ecode1 = 0 ;
12798 bool temp2 = false ;
12799 PyObject * obj0 = 0 ;
12800 PyObject * obj1 = 0 ;
12801 char * kwnames[] = {
12802 (char *) "level",(char *) "msg", NULL
12803 };
12804
12805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12806 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12807 if (!SWIG_IsOK(ecode1)) {
12808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12809 }
12810 arg1 = static_cast< unsigned long >(val1);
12811 {
12812 arg2 = wxString_in_helper(obj1);
12813 if (arg2 == NULL) SWIG_fail;
12814 temp2 = true;
12815 }
12816 {
12817 PyThreadState* __tstate = wxPyBeginAllowThreads();
12818 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12819 wxPyEndAllowThreads(__tstate);
12820 if (PyErr_Occurred()) SWIG_fail;
12821 }
12822 resultobj = SWIG_Py_Void();
12823 {
12824 if (temp2)
12825 delete arg2;
12826 }
12827 return resultobj;
12828 fail:
12829 {
12830 if (temp2)
12831 delete arg2;
12832 }
12833 return NULL;
12834 }
12835
12836
12837 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12838 PyObject *resultobj = 0;
12839 unsigned long arg1 ;
12840 wxString *arg2 = 0 ;
12841 unsigned long val1 ;
12842 int ecode1 = 0 ;
12843 bool temp2 = false ;
12844
12845 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12846 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12847 if (!SWIG_IsOK(ecode1)) {
12848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12849 }
12850 arg1 = static_cast< unsigned long >(val1);
12851 {
12852 arg2 = wxString_in_helper(swig_obj[1]);
12853 if (arg2 == NULL) SWIG_fail;
12854 temp2 = true;
12855 }
12856 {
12857 PyThreadState* __tstate = wxPyBeginAllowThreads();
12858 wxPyLogTrace(arg1,(wxString const &)*arg2);
12859 wxPyEndAllowThreads(__tstate);
12860 if (PyErr_Occurred()) SWIG_fail;
12861 }
12862 resultobj = SWIG_Py_Void();
12863 {
12864 if (temp2)
12865 delete arg2;
12866 }
12867 return resultobj;
12868 fail:
12869 {
12870 if (temp2)
12871 delete arg2;
12872 }
12873 return NULL;
12874 }
12875
12876
12877 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12878 PyObject *resultobj = 0;
12879 wxString *arg1 = 0 ;
12880 wxString *arg2 = 0 ;
12881 bool temp1 = false ;
12882 bool temp2 = false ;
12883
12884 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12885 {
12886 arg1 = wxString_in_helper(swig_obj[0]);
12887 if (arg1 == NULL) SWIG_fail;
12888 temp1 = true;
12889 }
12890 {
12891 arg2 = wxString_in_helper(swig_obj[1]);
12892 if (arg2 == NULL) SWIG_fail;
12893 temp2 = true;
12894 }
12895 {
12896 PyThreadState* __tstate = wxPyBeginAllowThreads();
12897 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12898 wxPyEndAllowThreads(__tstate);
12899 if (PyErr_Occurred()) SWIG_fail;
12900 }
12901 resultobj = SWIG_Py_Void();
12902 {
12903 if (temp1)
12904 delete arg1;
12905 }
12906 {
12907 if (temp2)
12908 delete arg2;
12909 }
12910 return resultobj;
12911 fail:
12912 {
12913 if (temp1)
12914 delete arg1;
12915 }
12916 {
12917 if (temp2)
12918 delete arg2;
12919 }
12920 return NULL;
12921 }
12922
12923
12924 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12925 int argc;
12926 PyObject *argv[3];
12927
12928 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12929 --argc;
12930 if (argc == 2) {
12931 int _v = 0;
12932 {
12933 {
12934 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12935 }
12936 }
12937 if (!_v) goto check_1;
12938 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12939 }
12940 check_1:
12941
12942 if (argc == 2) {
12943 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12944 }
12945
12946 fail:
12947 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12948 return NULL;
12949 }
12950
12951
12952 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12953 PyObject *resultobj = 0;
12954 wxString *arg1 = 0 ;
12955 wxString *arg2 = 0 ;
12956 bool temp1 = false ;
12957 bool temp2 = false ;
12958 PyObject * obj0 = 0 ;
12959 PyObject * obj1 = 0 ;
12960 char * kwnames[] = {
12961 (char *) "title",(char *) "text", NULL
12962 };
12963
12964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12965 {
12966 arg1 = wxString_in_helper(obj0);
12967 if (arg1 == NULL) SWIG_fail;
12968 temp1 = true;
12969 }
12970 {
12971 arg2 = wxString_in_helper(obj1);
12972 if (arg2 == NULL) SWIG_fail;
12973 temp2 = true;
12974 }
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12978 wxPyEndAllowThreads(__tstate);
12979 if (PyErr_Occurred()) SWIG_fail;
12980 }
12981 resultobj = SWIG_Py_Void();
12982 {
12983 if (temp1)
12984 delete arg1;
12985 }
12986 {
12987 if (temp2)
12988 delete arg2;
12989 }
12990 return resultobj;
12991 fail:
12992 {
12993 if (temp1)
12994 delete arg1;
12995 }
12996 {
12997 if (temp2)
12998 delete arg2;
12999 }
13000 return NULL;
13001 }
13002
13003
13004 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13005 PyObject *resultobj = 0;
13006 wxLogNull *result = 0 ;
13007
13008 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13009 {
13010 PyThreadState* __tstate = wxPyBeginAllowThreads();
13011 result = (wxLogNull *)new wxLogNull();
13012 wxPyEndAllowThreads(__tstate);
13013 if (PyErr_Occurred()) SWIG_fail;
13014 }
13015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13016 return resultobj;
13017 fail:
13018 return NULL;
13019 }
13020
13021
13022 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13023 PyObject *resultobj = 0;
13024 wxLogNull *arg1 = (wxLogNull *) 0 ;
13025 void *argp1 = 0 ;
13026 int res1 = 0 ;
13027 PyObject *swig_obj[1] ;
13028
13029 if (!args) SWIG_fail;
13030 swig_obj[0] = args;
13031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
13032 if (!SWIG_IsOK(res1)) {
13033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
13034 }
13035 arg1 = reinterpret_cast< wxLogNull * >(argp1);
13036 {
13037 PyThreadState* __tstate = wxPyBeginAllowThreads();
13038 delete arg1;
13039
13040 wxPyEndAllowThreads(__tstate);
13041 if (PyErr_Occurred()) SWIG_fail;
13042 }
13043 resultobj = SWIG_Py_Void();
13044 return resultobj;
13045 fail:
13046 return NULL;
13047 }
13048
13049
13050 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13051 PyObject *obj;
13052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13053 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
13054 return SWIG_Py_Void();
13055 }
13056
13057 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13058 return SWIG_Python_InitShadowInstance(args);
13059 }
13060
13061 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13062 PyObject *resultobj = 0;
13063 wxPyLog *result = 0 ;
13064
13065 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
13066 {
13067 PyThreadState* __tstate = wxPyBeginAllowThreads();
13068 result = (wxPyLog *)new wxPyLog();
13069 wxPyEndAllowThreads(__tstate);
13070 if (PyErr_Occurred()) SWIG_fail;
13071 }
13072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
13073 return resultobj;
13074 fail:
13075 return NULL;
13076 }
13077
13078
13079 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13080 PyObject *resultobj = 0;
13081 wxPyLog *arg1 = (wxPyLog *) 0 ;
13082 PyObject *arg2 = (PyObject *) 0 ;
13083 PyObject *arg3 = (PyObject *) 0 ;
13084 void *argp1 = 0 ;
13085 int res1 = 0 ;
13086 PyObject * obj0 = 0 ;
13087 PyObject * obj1 = 0 ;
13088 PyObject * obj2 = 0 ;
13089 char * kwnames[] = {
13090 (char *) "self",(char *) "self",(char *) "_class", NULL
13091 };
13092
13093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
13095 if (!SWIG_IsOK(res1)) {
13096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
13097 }
13098 arg1 = reinterpret_cast< wxPyLog * >(argp1);
13099 arg2 = obj1;
13100 arg3 = obj2;
13101 {
13102 PyThreadState* __tstate = wxPyBeginAllowThreads();
13103 (arg1)->_setCallbackInfo(arg2,arg3);
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 *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13115 PyObject *obj;
13116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13117 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
13118 return SWIG_Py_Void();
13119 }
13120
13121 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13122 return SWIG_Python_InitShadowInstance(args);
13123 }
13124
13125 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13126 PyObject *resultobj = 0;
13127 int arg1 ;
13128 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13129 int arg3 = (int) wxKILL_NOCHILDREN ;
13130 wxKillError result;
13131 int val1 ;
13132 int ecode1 = 0 ;
13133 int val2 ;
13134 int ecode2 = 0 ;
13135 int val3 ;
13136 int ecode3 = 0 ;
13137 PyObject * obj0 = 0 ;
13138 PyObject * obj1 = 0 ;
13139 PyObject * obj2 = 0 ;
13140 char * kwnames[] = {
13141 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13142 };
13143
13144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13145 ecode1 = SWIG_AsVal_int(obj0, &val1);
13146 if (!SWIG_IsOK(ecode1)) {
13147 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13148 }
13149 arg1 = static_cast< int >(val1);
13150 if (obj1) {
13151 ecode2 = SWIG_AsVal_int(obj1, &val2);
13152 if (!SWIG_IsOK(ecode2)) {
13153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13154 }
13155 arg2 = static_cast< wxSignal >(val2);
13156 }
13157 if (obj2) {
13158 ecode3 = SWIG_AsVal_int(obj2, &val3);
13159 if (!SWIG_IsOK(ecode3)) {
13160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13161 }
13162 arg3 = static_cast< int >(val3);
13163 }
13164 {
13165 PyThreadState* __tstate = wxPyBeginAllowThreads();
13166 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 resultobj = SWIG_From_int(static_cast< int >(result));
13171 return resultobj;
13172 fail:
13173 return NULL;
13174 }
13175
13176
13177 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13178 PyObject *resultobj = 0;
13179 int arg1 ;
13180 bool result;
13181 int val1 ;
13182 int ecode1 = 0 ;
13183 PyObject * obj0 = 0 ;
13184 char * kwnames[] = {
13185 (char *) "pid", NULL
13186 };
13187
13188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13189 ecode1 = SWIG_AsVal_int(obj0, &val1);
13190 if (!SWIG_IsOK(ecode1)) {
13191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13192 }
13193 arg1 = static_cast< int >(val1);
13194 {
13195 PyThreadState* __tstate = wxPyBeginAllowThreads();
13196 result = (bool)wxPyProcess::Exists(arg1);
13197 wxPyEndAllowThreads(__tstate);
13198 if (PyErr_Occurred()) SWIG_fail;
13199 }
13200 {
13201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13202 }
13203 return resultobj;
13204 fail:
13205 return NULL;
13206 }
13207
13208
13209 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13210 PyObject *resultobj = 0;
13211 wxString *arg1 = 0 ;
13212 int arg2 = (int) wxEXEC_ASYNC ;
13213 wxPyProcess *result = 0 ;
13214 bool temp1 = false ;
13215 int val2 ;
13216 int ecode2 = 0 ;
13217 PyObject * obj0 = 0 ;
13218 PyObject * obj1 = 0 ;
13219 char * kwnames[] = {
13220 (char *) "cmd",(char *) "flags", NULL
13221 };
13222
13223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13224 {
13225 arg1 = wxString_in_helper(obj0);
13226 if (arg1 == NULL) SWIG_fail;
13227 temp1 = true;
13228 }
13229 if (obj1) {
13230 ecode2 = SWIG_AsVal_int(obj1, &val2);
13231 if (!SWIG_IsOK(ecode2)) {
13232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13233 }
13234 arg2 = static_cast< int >(val2);
13235 }
13236 {
13237 PyThreadState* __tstate = wxPyBeginAllowThreads();
13238 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13239 wxPyEndAllowThreads(__tstate);
13240 if (PyErr_Occurred()) SWIG_fail;
13241 }
13242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13243 {
13244 if (temp1)
13245 delete arg1;
13246 }
13247 return resultobj;
13248 fail:
13249 {
13250 if (temp1)
13251 delete arg1;
13252 }
13253 return NULL;
13254 }
13255
13256
13257 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13258 PyObject *resultobj = 0;
13259 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13260 int arg2 = (int) -1 ;
13261 wxPyProcess *result = 0 ;
13262 void *argp1 = 0 ;
13263 int res1 = 0 ;
13264 int val2 ;
13265 int ecode2 = 0 ;
13266 PyObject * obj0 = 0 ;
13267 PyObject * obj1 = 0 ;
13268 char * kwnames[] = {
13269 (char *) "parent",(char *) "id", NULL
13270 };
13271
13272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13273 if (obj0) {
13274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13275 if (!SWIG_IsOK(res1)) {
13276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13277 }
13278 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13279 }
13280 if (obj1) {
13281 ecode2 = SWIG_AsVal_int(obj1, &val2);
13282 if (!SWIG_IsOK(ecode2)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13284 }
13285 arg2 = static_cast< int >(val2);
13286 }
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13294 return resultobj;
13295 fail:
13296 return NULL;
13297 }
13298
13299
13300 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13301 PyObject *resultobj = 0;
13302 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13303 PyObject *arg2 = (PyObject *) 0 ;
13304 PyObject *arg3 = (PyObject *) 0 ;
13305 void *argp1 = 0 ;
13306 int res1 = 0 ;
13307 PyObject * obj0 = 0 ;
13308 PyObject * obj1 = 0 ;
13309 PyObject * obj2 = 0 ;
13310 char * kwnames[] = {
13311 (char *) "self",(char *) "self",(char *) "_class", NULL
13312 };
13313
13314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13316 if (!SWIG_IsOK(res1)) {
13317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13318 }
13319 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13320 arg2 = obj1;
13321 arg3 = obj2;
13322 {
13323 PyThreadState* __tstate = wxPyBeginAllowThreads();
13324 (arg1)->_setCallbackInfo(arg2,arg3);
13325 wxPyEndAllowThreads(__tstate);
13326 if (PyErr_Occurred()) SWIG_fail;
13327 }
13328 resultobj = SWIG_Py_Void();
13329 return resultobj;
13330 fail:
13331 return NULL;
13332 }
13333
13334
13335 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13336 PyObject *resultobj = 0;
13337 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13338 int arg2 ;
13339 int arg3 ;
13340 void *argp1 = 0 ;
13341 int res1 = 0 ;
13342 int val2 ;
13343 int ecode2 = 0 ;
13344 int val3 ;
13345 int ecode3 = 0 ;
13346 PyObject * obj0 = 0 ;
13347 PyObject * obj1 = 0 ;
13348 PyObject * obj2 = 0 ;
13349 char * kwnames[] = {
13350 (char *) "self",(char *) "pid",(char *) "status", NULL
13351 };
13352
13353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13355 if (!SWIG_IsOK(res1)) {
13356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13357 }
13358 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13359 ecode2 = SWIG_AsVal_int(obj1, &val2);
13360 if (!SWIG_IsOK(ecode2)) {
13361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13362 }
13363 arg2 = static_cast< int >(val2);
13364 ecode3 = SWIG_AsVal_int(obj2, &val3);
13365 if (!SWIG_IsOK(ecode3)) {
13366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13367 }
13368 arg3 = static_cast< int >(val3);
13369 {
13370 PyThreadState* __tstate = wxPyBeginAllowThreads();
13371 (arg1)->OnTerminate(arg2,arg3);
13372 wxPyEndAllowThreads(__tstate);
13373 if (PyErr_Occurred()) SWIG_fail;
13374 }
13375 resultobj = SWIG_Py_Void();
13376 return resultobj;
13377 fail:
13378 return NULL;
13379 }
13380
13381
13382 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13383 PyObject *resultobj = 0;
13384 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13385 void *argp1 = 0 ;
13386 int res1 = 0 ;
13387 PyObject *swig_obj[1] ;
13388
13389 if (!args) SWIG_fail;
13390 swig_obj[0] = args;
13391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13392 if (!SWIG_IsOK(res1)) {
13393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13394 }
13395 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13396 {
13397 PyThreadState* __tstate = wxPyBeginAllowThreads();
13398 (arg1)->Redirect();
13399 wxPyEndAllowThreads(__tstate);
13400 if (PyErr_Occurred()) SWIG_fail;
13401 }
13402 resultobj = SWIG_Py_Void();
13403 return resultobj;
13404 fail:
13405 return NULL;
13406 }
13407
13408
13409 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13410 PyObject *resultobj = 0;
13411 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13412 bool result;
13413 void *argp1 = 0 ;
13414 int res1 = 0 ;
13415 PyObject *swig_obj[1] ;
13416
13417 if (!args) SWIG_fail;
13418 swig_obj[0] = args;
13419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13420 if (!SWIG_IsOK(res1)) {
13421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13422 }
13423 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 result = (bool)(arg1)->IsRedirected();
13427 wxPyEndAllowThreads(__tstate);
13428 if (PyErr_Occurred()) SWIG_fail;
13429 }
13430 {
13431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13432 }
13433 return resultobj;
13434 fail:
13435 return NULL;
13436 }
13437
13438
13439 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13440 PyObject *resultobj = 0;
13441 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13442 void *argp1 = 0 ;
13443 int res1 = 0 ;
13444 PyObject *swig_obj[1] ;
13445
13446 if (!args) SWIG_fail;
13447 swig_obj[0] = args;
13448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13449 if (!SWIG_IsOK(res1)) {
13450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13451 }
13452 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 (arg1)->Detach();
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 resultobj = SWIG_Py_Void();
13460 return resultobj;
13461 fail:
13462 return NULL;
13463 }
13464
13465
13466 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13467 PyObject *resultobj = 0;
13468 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13469 wxInputStream *result = 0 ;
13470 void *argp1 = 0 ;
13471 int res1 = 0 ;
13472 PyObject *swig_obj[1] ;
13473
13474 if (!args) SWIG_fail;
13475 swig_obj[0] = args;
13476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13477 if (!SWIG_IsOK(res1)) {
13478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13479 }
13480 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 result = (wxInputStream *)(arg1)->GetInputStream();
13484 wxPyEndAllowThreads(__tstate);
13485 if (PyErr_Occurred()) SWIG_fail;
13486 }
13487 {
13488 wxPyInputStream * _ptr = NULL;
13489
13490 if (result) {
13491 _ptr = new wxPyInputStream(result);
13492 }
13493 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13494 }
13495 return resultobj;
13496 fail:
13497 return NULL;
13498 }
13499
13500
13501 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13502 PyObject *resultobj = 0;
13503 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13504 wxInputStream *result = 0 ;
13505 void *argp1 = 0 ;
13506 int res1 = 0 ;
13507 PyObject *swig_obj[1] ;
13508
13509 if (!args) SWIG_fail;
13510 swig_obj[0] = args;
13511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13512 if (!SWIG_IsOK(res1)) {
13513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13514 }
13515 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13516 {
13517 PyThreadState* __tstate = wxPyBeginAllowThreads();
13518 result = (wxInputStream *)(arg1)->GetErrorStream();
13519 wxPyEndAllowThreads(__tstate);
13520 if (PyErr_Occurred()) SWIG_fail;
13521 }
13522 {
13523 wxPyInputStream * _ptr = NULL;
13524
13525 if (result) {
13526 _ptr = new wxPyInputStream(result);
13527 }
13528 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13529 }
13530 return resultobj;
13531 fail:
13532 return NULL;
13533 }
13534
13535
13536 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13537 PyObject *resultobj = 0;
13538 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13539 wxOutputStream *result = 0 ;
13540 void *argp1 = 0 ;
13541 int res1 = 0 ;
13542 PyObject *swig_obj[1] ;
13543
13544 if (!args) SWIG_fail;
13545 swig_obj[0] = args;
13546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13547 if (!SWIG_IsOK(res1)) {
13548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13549 }
13550 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 result = (wxOutputStream *)(arg1)->GetOutputStream();
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13558 return resultobj;
13559 fail:
13560 return NULL;
13561 }
13562
13563
13564 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13565 PyObject *resultobj = 0;
13566 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13567 void *argp1 = 0 ;
13568 int res1 = 0 ;
13569 PyObject *swig_obj[1] ;
13570
13571 if (!args) SWIG_fail;
13572 swig_obj[0] = args;
13573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13574 if (!SWIG_IsOK(res1)) {
13575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13576 }
13577 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13578 {
13579 PyThreadState* __tstate = wxPyBeginAllowThreads();
13580 (arg1)->CloseOutput();
13581 wxPyEndAllowThreads(__tstate);
13582 if (PyErr_Occurred()) SWIG_fail;
13583 }
13584 resultobj = SWIG_Py_Void();
13585 return resultobj;
13586 fail:
13587 return NULL;
13588 }
13589
13590
13591 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13592 PyObject *resultobj = 0;
13593 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13594 bool result;
13595 void *argp1 = 0 ;
13596 int res1 = 0 ;
13597 PyObject *swig_obj[1] ;
13598
13599 if (!args) SWIG_fail;
13600 swig_obj[0] = args;
13601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13602 if (!SWIG_IsOK(res1)) {
13603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13604 }
13605 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13606 {
13607 PyThreadState* __tstate = wxPyBeginAllowThreads();
13608 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 {
13613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13614 }
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13622 PyObject *resultobj = 0;
13623 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13624 bool result;
13625 void *argp1 = 0 ;
13626 int res1 = 0 ;
13627 PyObject *swig_obj[1] ;
13628
13629 if (!args) SWIG_fail;
13630 swig_obj[0] = args;
13631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13632 if (!SWIG_IsOK(res1)) {
13633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13634 }
13635 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13636 {
13637 PyThreadState* __tstate = wxPyBeginAllowThreads();
13638 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13639 wxPyEndAllowThreads(__tstate);
13640 if (PyErr_Occurred()) SWIG_fail;
13641 }
13642 {
13643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13644 }
13645 return resultobj;
13646 fail:
13647 return NULL;
13648 }
13649
13650
13651 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13652 PyObject *resultobj = 0;
13653 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13654 bool result;
13655 void *argp1 = 0 ;
13656 int res1 = 0 ;
13657 PyObject *swig_obj[1] ;
13658
13659 if (!args) SWIG_fail;
13660 swig_obj[0] = args;
13661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13662 if (!SWIG_IsOK(res1)) {
13663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13664 }
13665 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13666 {
13667 PyThreadState* __tstate = wxPyBeginAllowThreads();
13668 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 {
13673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13674 }
13675 return resultobj;
13676 fail:
13677 return NULL;
13678 }
13679
13680
13681 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13682 PyObject *obj;
13683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13684 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13685 return SWIG_Py_Void();
13686 }
13687
13688 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13689 return SWIG_Python_InitShadowInstance(args);
13690 }
13691
13692 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13693 PyObject *resultobj = 0;
13694 int arg1 = (int) 0 ;
13695 int arg2 = (int) 0 ;
13696 int arg3 = (int) 0 ;
13697 wxProcessEvent *result = 0 ;
13698 int val1 ;
13699 int ecode1 = 0 ;
13700 int val2 ;
13701 int ecode2 = 0 ;
13702 int val3 ;
13703 int ecode3 = 0 ;
13704 PyObject * obj0 = 0 ;
13705 PyObject * obj1 = 0 ;
13706 PyObject * obj2 = 0 ;
13707 char * kwnames[] = {
13708 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13709 };
13710
13711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13712 if (obj0) {
13713 ecode1 = SWIG_AsVal_int(obj0, &val1);
13714 if (!SWIG_IsOK(ecode1)) {
13715 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13716 }
13717 arg1 = static_cast< int >(val1);
13718 }
13719 if (obj1) {
13720 ecode2 = SWIG_AsVal_int(obj1, &val2);
13721 if (!SWIG_IsOK(ecode2)) {
13722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13723 }
13724 arg2 = static_cast< int >(val2);
13725 }
13726 if (obj2) {
13727 ecode3 = SWIG_AsVal_int(obj2, &val3);
13728 if (!SWIG_IsOK(ecode3)) {
13729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13730 }
13731 arg3 = static_cast< int >(val3);
13732 }
13733 {
13734 PyThreadState* __tstate = wxPyBeginAllowThreads();
13735 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13736 wxPyEndAllowThreads(__tstate);
13737 if (PyErr_Occurred()) SWIG_fail;
13738 }
13739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13740 return resultobj;
13741 fail:
13742 return NULL;
13743 }
13744
13745
13746 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13747 PyObject *resultobj = 0;
13748 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13749 int result;
13750 void *argp1 = 0 ;
13751 int res1 = 0 ;
13752 PyObject *swig_obj[1] ;
13753
13754 if (!args) SWIG_fail;
13755 swig_obj[0] = args;
13756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13757 if (!SWIG_IsOK(res1)) {
13758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13759 }
13760 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13761 {
13762 PyThreadState* __tstate = wxPyBeginAllowThreads();
13763 result = (int)(arg1)->GetPid();
13764 wxPyEndAllowThreads(__tstate);
13765 if (PyErr_Occurred()) SWIG_fail;
13766 }
13767 resultobj = SWIG_From_int(static_cast< int >(result));
13768 return resultobj;
13769 fail:
13770 return NULL;
13771 }
13772
13773
13774 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13775 PyObject *resultobj = 0;
13776 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13777 int result;
13778 void *argp1 = 0 ;
13779 int res1 = 0 ;
13780 PyObject *swig_obj[1] ;
13781
13782 if (!args) SWIG_fail;
13783 swig_obj[0] = args;
13784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13785 if (!SWIG_IsOK(res1)) {
13786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13787 }
13788 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13789 {
13790 PyThreadState* __tstate = wxPyBeginAllowThreads();
13791 result = (int)(arg1)->GetExitCode();
13792 wxPyEndAllowThreads(__tstate);
13793 if (PyErr_Occurred()) SWIG_fail;
13794 }
13795 resultobj = SWIG_From_int(static_cast< int >(result));
13796 return resultobj;
13797 fail:
13798 return NULL;
13799 }
13800
13801
13802 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13803 PyObject *resultobj = 0;
13804 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13805 int arg2 ;
13806 void *argp1 = 0 ;
13807 int res1 = 0 ;
13808 int val2 ;
13809 int ecode2 = 0 ;
13810 PyObject *swig_obj[2] ;
13811
13812 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13814 if (!SWIG_IsOK(res1)) {
13815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13816 }
13817 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13818 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13819 if (!SWIG_IsOK(ecode2)) {
13820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13821 }
13822 arg2 = static_cast< int >(val2);
13823 if (arg1) (arg1)->m_pid = arg2;
13824
13825 resultobj = SWIG_Py_Void();
13826 return resultobj;
13827 fail:
13828 return NULL;
13829 }
13830
13831
13832 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13833 PyObject *resultobj = 0;
13834 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13835 int result;
13836 void *argp1 = 0 ;
13837 int res1 = 0 ;
13838 PyObject *swig_obj[1] ;
13839
13840 if (!args) SWIG_fail;
13841 swig_obj[0] = args;
13842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13843 if (!SWIG_IsOK(res1)) {
13844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13845 }
13846 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13847 result = (int) ((arg1)->m_pid);
13848 resultobj = SWIG_From_int(static_cast< int >(result));
13849 return resultobj;
13850 fail:
13851 return NULL;
13852 }
13853
13854
13855 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13856 PyObject *resultobj = 0;
13857 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13858 int arg2 ;
13859 void *argp1 = 0 ;
13860 int res1 = 0 ;
13861 int val2 ;
13862 int ecode2 = 0 ;
13863 PyObject *swig_obj[2] ;
13864
13865 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13867 if (!SWIG_IsOK(res1)) {
13868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13869 }
13870 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13871 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13872 if (!SWIG_IsOK(ecode2)) {
13873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13874 }
13875 arg2 = static_cast< int >(val2);
13876 if (arg1) (arg1)->m_exitcode = arg2;
13877
13878 resultobj = SWIG_Py_Void();
13879 return resultobj;
13880 fail:
13881 return NULL;
13882 }
13883
13884
13885 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13886 PyObject *resultobj = 0;
13887 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13888 int result;
13889 void *argp1 = 0 ;
13890 int res1 = 0 ;
13891 PyObject *swig_obj[1] ;
13892
13893 if (!args) SWIG_fail;
13894 swig_obj[0] = args;
13895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13896 if (!SWIG_IsOK(res1)) {
13897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13898 }
13899 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13900 result = (int) ((arg1)->m_exitcode);
13901 resultobj = SWIG_From_int(static_cast< int >(result));
13902 return resultobj;
13903 fail:
13904 return NULL;
13905 }
13906
13907
13908 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13909 PyObject *obj;
13910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13911 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13912 return SWIG_Py_Void();
13913 }
13914
13915 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13916 return SWIG_Python_InitShadowInstance(args);
13917 }
13918
13919 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13920 PyObject *resultobj = 0;
13921 wxString *arg1 = 0 ;
13922 int arg2 = (int) wxEXEC_ASYNC ;
13923 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13924 long result;
13925 bool temp1 = false ;
13926 int val2 ;
13927 int ecode2 = 0 ;
13928 void *argp3 = 0 ;
13929 int res3 = 0 ;
13930 PyObject * obj0 = 0 ;
13931 PyObject * obj1 = 0 ;
13932 PyObject * obj2 = 0 ;
13933 char * kwnames[] = {
13934 (char *) "command",(char *) "flags",(char *) "process", NULL
13935 };
13936
13937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13938 {
13939 arg1 = wxString_in_helper(obj0);
13940 if (arg1 == NULL) SWIG_fail;
13941 temp1 = true;
13942 }
13943 if (obj1) {
13944 ecode2 = SWIG_AsVal_int(obj1, &val2);
13945 if (!SWIG_IsOK(ecode2)) {
13946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13947 }
13948 arg2 = static_cast< int >(val2);
13949 }
13950 if (obj2) {
13951 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13952 if (!SWIG_IsOK(res3)) {
13953 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13954 }
13955 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13956 }
13957 {
13958 if (!wxPyCheckForApp()) SWIG_fail;
13959 PyThreadState* __tstate = wxPyBeginAllowThreads();
13960 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13961 wxPyEndAllowThreads(__tstate);
13962 if (PyErr_Occurred()) SWIG_fail;
13963 }
13964 resultobj = SWIG_From_long(static_cast< long >(result));
13965 {
13966 if (temp1)
13967 delete arg1;
13968 }
13969 return resultobj;
13970 fail:
13971 {
13972 if (temp1)
13973 delete arg1;
13974 }
13975 return NULL;
13976 }
13977
13978
13979 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13980 PyObject *resultobj = 0;
13981 long arg1 ;
13982 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13983 wxKillError *arg3 = (wxKillError *) 0 ;
13984 int arg4 = (int) wxKILL_NOCHILDREN ;
13985 int result;
13986 long val1 ;
13987 int ecode1 = 0 ;
13988 int val2 ;
13989 int ecode2 = 0 ;
13990 wxKillError temp3 ;
13991 int val4 ;
13992 int ecode4 = 0 ;
13993 PyObject * obj0 = 0 ;
13994 PyObject * obj1 = 0 ;
13995 PyObject * obj2 = 0 ;
13996 char * kwnames[] = {
13997 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13998 };
13999
14000 {
14001 arg3 = &temp3;
14002 }
14003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14004 ecode1 = SWIG_AsVal_long(obj0, &val1);
14005 if (!SWIG_IsOK(ecode1)) {
14006 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14007 }
14008 arg1 = static_cast< long >(val1);
14009 if (obj1) {
14010 ecode2 = SWIG_AsVal_int(obj1, &val2);
14011 if (!SWIG_IsOK(ecode2)) {
14012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14013 }
14014 arg2 = static_cast< wxSignal >(val2);
14015 }
14016 if (obj2) {
14017 ecode4 = SWIG_AsVal_int(obj2, &val4);
14018 if (!SWIG_IsOK(ecode4)) {
14019 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14020 }
14021 arg4 = static_cast< int >(val4);
14022 }
14023 {
14024 PyThreadState* __tstate = wxPyBeginAllowThreads();
14025 result = (int)wxKill(arg1,arg2,arg3,arg4);
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 resultobj = SWIG_From_int(static_cast< int >(result));
14030 {
14031 PyObject* o;
14032 o = PyInt_FromLong((long) (*arg3));
14033
14034
14035
14036 resultobj = SWIG_Python_AppendOutput(resultobj, o);
14037
14038 }
14039 return resultobj;
14040 fail:
14041 return NULL;
14042 }
14043
14044
14045 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14046 PyObject *resultobj = 0;
14047 int arg1 = (int) wxJOYSTICK1 ;
14048 wxJoystick *result = 0 ;
14049 int val1 ;
14050 int ecode1 = 0 ;
14051 PyObject * obj0 = 0 ;
14052 char * kwnames[] = {
14053 (char *) "joystick", NULL
14054 };
14055
14056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
14057 if (obj0) {
14058 ecode1 = SWIG_AsVal_int(obj0, &val1);
14059 if (!SWIG_IsOK(ecode1)) {
14060 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
14061 }
14062 arg1 = static_cast< int >(val1);
14063 }
14064 {
14065 if (!wxPyCheckForApp()) SWIG_fail;
14066 PyThreadState* __tstate = wxPyBeginAllowThreads();
14067 result = (wxJoystick *)new wxJoystick(arg1);
14068 wxPyEndAllowThreads(__tstate);
14069 if (PyErr_Occurred()) SWIG_fail;
14070 }
14071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
14072 return resultobj;
14073 fail:
14074 return NULL;
14075 }
14076
14077
14078 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14079 PyObject *resultobj = 0;
14080 wxJoystick *arg1 = (wxJoystick *) 0 ;
14081 void *argp1 = 0 ;
14082 int res1 = 0 ;
14083 PyObject *swig_obj[1] ;
14084
14085 if (!args) SWIG_fail;
14086 swig_obj[0] = args;
14087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
14088 if (!SWIG_IsOK(res1)) {
14089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
14090 }
14091 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 delete arg1;
14095
14096 wxPyEndAllowThreads(__tstate);
14097 if (PyErr_Occurred()) SWIG_fail;
14098 }
14099 resultobj = SWIG_Py_Void();
14100 return resultobj;
14101 fail:
14102 return NULL;
14103 }
14104
14105
14106 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14107 PyObject *resultobj = 0;
14108 wxJoystick *arg1 = (wxJoystick *) 0 ;
14109 wxPoint result;
14110 void *argp1 = 0 ;
14111 int res1 = 0 ;
14112 PyObject *swig_obj[1] ;
14113
14114 if (!args) SWIG_fail;
14115 swig_obj[0] = args;
14116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14117 if (!SWIG_IsOK(res1)) {
14118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14119 }
14120 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14121 {
14122 PyThreadState* __tstate = wxPyBeginAllowThreads();
14123 result = (arg1)->GetPosition();
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14128 return resultobj;
14129 fail:
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14135 PyObject *resultobj = 0;
14136 wxJoystick *arg1 = (wxJoystick *) 0 ;
14137 int result;
14138 void *argp1 = 0 ;
14139 int res1 = 0 ;
14140 PyObject *swig_obj[1] ;
14141
14142 if (!args) SWIG_fail;
14143 swig_obj[0] = args;
14144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14145 if (!SWIG_IsOK(res1)) {
14146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14147 }
14148 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14149 {
14150 PyThreadState* __tstate = wxPyBeginAllowThreads();
14151 result = (int)(arg1)->GetZPosition();
14152 wxPyEndAllowThreads(__tstate);
14153 if (PyErr_Occurred()) SWIG_fail;
14154 }
14155 resultobj = SWIG_From_int(static_cast< int >(result));
14156 return resultobj;
14157 fail:
14158 return NULL;
14159 }
14160
14161
14162 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14163 PyObject *resultobj = 0;
14164 wxJoystick *arg1 = (wxJoystick *) 0 ;
14165 int result;
14166 void *argp1 = 0 ;
14167 int res1 = 0 ;
14168 PyObject *swig_obj[1] ;
14169
14170 if (!args) SWIG_fail;
14171 swig_obj[0] = args;
14172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14173 if (!SWIG_IsOK(res1)) {
14174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14175 }
14176 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14177 {
14178 PyThreadState* __tstate = wxPyBeginAllowThreads();
14179 result = (int)(arg1)->GetButtonState();
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 resultobj = SWIG_From_int(static_cast< int >(result));
14184 return resultobj;
14185 fail:
14186 return NULL;
14187 }
14188
14189
14190 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14191 PyObject *resultobj = 0;
14192 wxJoystick *arg1 = (wxJoystick *) 0 ;
14193 int result;
14194 void *argp1 = 0 ;
14195 int res1 = 0 ;
14196 PyObject *swig_obj[1] ;
14197
14198 if (!args) SWIG_fail;
14199 swig_obj[0] = args;
14200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14201 if (!SWIG_IsOK(res1)) {
14202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14203 }
14204 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14205 {
14206 PyThreadState* __tstate = wxPyBeginAllowThreads();
14207 result = (int)(arg1)->GetPOVPosition();
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 resultobj = SWIG_From_int(static_cast< int >(result));
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14219 PyObject *resultobj = 0;
14220 wxJoystick *arg1 = (wxJoystick *) 0 ;
14221 int result;
14222 void *argp1 = 0 ;
14223 int res1 = 0 ;
14224 PyObject *swig_obj[1] ;
14225
14226 if (!args) SWIG_fail;
14227 swig_obj[0] = args;
14228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14229 if (!SWIG_IsOK(res1)) {
14230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14231 }
14232 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14233 {
14234 PyThreadState* __tstate = wxPyBeginAllowThreads();
14235 result = (int)(arg1)->GetPOVCTSPosition();
14236 wxPyEndAllowThreads(__tstate);
14237 if (PyErr_Occurred()) SWIG_fail;
14238 }
14239 resultobj = SWIG_From_int(static_cast< int >(result));
14240 return resultobj;
14241 fail:
14242 return NULL;
14243 }
14244
14245
14246 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14247 PyObject *resultobj = 0;
14248 wxJoystick *arg1 = (wxJoystick *) 0 ;
14249 int result;
14250 void *argp1 = 0 ;
14251 int res1 = 0 ;
14252 PyObject *swig_obj[1] ;
14253
14254 if (!args) SWIG_fail;
14255 swig_obj[0] = args;
14256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14257 if (!SWIG_IsOK(res1)) {
14258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14259 }
14260 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14261 {
14262 PyThreadState* __tstate = wxPyBeginAllowThreads();
14263 result = (int)(arg1)->GetRudderPosition();
14264 wxPyEndAllowThreads(__tstate);
14265 if (PyErr_Occurred()) SWIG_fail;
14266 }
14267 resultobj = SWIG_From_int(static_cast< int >(result));
14268 return resultobj;
14269 fail:
14270 return NULL;
14271 }
14272
14273
14274 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14275 PyObject *resultobj = 0;
14276 wxJoystick *arg1 = (wxJoystick *) 0 ;
14277 int result;
14278 void *argp1 = 0 ;
14279 int res1 = 0 ;
14280 PyObject *swig_obj[1] ;
14281
14282 if (!args) SWIG_fail;
14283 swig_obj[0] = args;
14284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14285 if (!SWIG_IsOK(res1)) {
14286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14287 }
14288 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14289 {
14290 PyThreadState* __tstate = wxPyBeginAllowThreads();
14291 result = (int)(arg1)->GetUPosition();
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_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14303 PyObject *resultobj = 0;
14304 wxJoystick *arg1 = (wxJoystick *) 0 ;
14305 int result;
14306 void *argp1 = 0 ;
14307 int res1 = 0 ;
14308 PyObject *swig_obj[1] ;
14309
14310 if (!args) SWIG_fail;
14311 swig_obj[0] = args;
14312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14313 if (!SWIG_IsOK(res1)) {
14314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14315 }
14316 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (int)(arg1)->GetVPosition();
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 resultobj = SWIG_From_int(static_cast< int >(result));
14324 return resultobj;
14325 fail:
14326 return NULL;
14327 }
14328
14329
14330 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14331 PyObject *resultobj = 0;
14332 wxJoystick *arg1 = (wxJoystick *) 0 ;
14333 int result;
14334 void *argp1 = 0 ;
14335 int res1 = 0 ;
14336 PyObject *swig_obj[1] ;
14337
14338 if (!args) SWIG_fail;
14339 swig_obj[0] = args;
14340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14341 if (!SWIG_IsOK(res1)) {
14342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14343 }
14344 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14345 {
14346 PyThreadState* __tstate = wxPyBeginAllowThreads();
14347 result = (int)(arg1)->GetMovementThreshold();
14348 wxPyEndAllowThreads(__tstate);
14349 if (PyErr_Occurred()) SWIG_fail;
14350 }
14351 resultobj = SWIG_From_int(static_cast< int >(result));
14352 return resultobj;
14353 fail:
14354 return NULL;
14355 }
14356
14357
14358 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj = 0;
14360 wxJoystick *arg1 = (wxJoystick *) 0 ;
14361 int arg2 ;
14362 void *argp1 = 0 ;
14363 int res1 = 0 ;
14364 int val2 ;
14365 int ecode2 = 0 ;
14366 PyObject * obj0 = 0 ;
14367 PyObject * obj1 = 0 ;
14368 char * kwnames[] = {
14369 (char *) "self",(char *) "threshold", NULL
14370 };
14371
14372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14374 if (!SWIG_IsOK(res1)) {
14375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14376 }
14377 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14378 ecode2 = SWIG_AsVal_int(obj1, &val2);
14379 if (!SWIG_IsOK(ecode2)) {
14380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14381 }
14382 arg2 = static_cast< int >(val2);
14383 {
14384 PyThreadState* __tstate = wxPyBeginAllowThreads();
14385 (arg1)->SetMovementThreshold(arg2);
14386 wxPyEndAllowThreads(__tstate);
14387 if (PyErr_Occurred()) SWIG_fail;
14388 }
14389 resultobj = SWIG_Py_Void();
14390 return resultobj;
14391 fail:
14392 return NULL;
14393 }
14394
14395
14396 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14397 PyObject *resultobj = 0;
14398 wxJoystick *arg1 = (wxJoystick *) 0 ;
14399 bool result;
14400 void *argp1 = 0 ;
14401 int res1 = 0 ;
14402 PyObject *swig_obj[1] ;
14403
14404 if (!args) SWIG_fail;
14405 swig_obj[0] = args;
14406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14407 if (!SWIG_IsOK(res1)) {
14408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14409 }
14410 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14411 {
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 result = (bool)(arg1)->IsOk();
14414 wxPyEndAllowThreads(__tstate);
14415 if (PyErr_Occurred()) SWIG_fail;
14416 }
14417 {
14418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14419 }
14420 return resultobj;
14421 fail:
14422 return NULL;
14423 }
14424
14425
14426 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14427 PyObject *resultobj = 0;
14428 wxJoystick *arg1 = (wxJoystick *) 0 ;
14429 int result;
14430 void *argp1 = 0 ;
14431 int res1 = 0 ;
14432 PyObject *swig_obj[1] ;
14433
14434 if (!args) SWIG_fail;
14435 swig_obj[0] = args;
14436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14437 if (!SWIG_IsOK(res1)) {
14438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14439 }
14440 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14441 {
14442 PyThreadState* __tstate = wxPyBeginAllowThreads();
14443 result = (int)(arg1)->GetNumberJoysticks();
14444 wxPyEndAllowThreads(__tstate);
14445 if (PyErr_Occurred()) SWIG_fail;
14446 }
14447 resultobj = SWIG_From_int(static_cast< int >(result));
14448 return resultobj;
14449 fail:
14450 return NULL;
14451 }
14452
14453
14454 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14455 PyObject *resultobj = 0;
14456 wxJoystick *arg1 = (wxJoystick *) 0 ;
14457 int result;
14458 void *argp1 = 0 ;
14459 int res1 = 0 ;
14460 PyObject *swig_obj[1] ;
14461
14462 if (!args) SWIG_fail;
14463 swig_obj[0] = args;
14464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14465 if (!SWIG_IsOK(res1)) {
14466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14467 }
14468 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14469 {
14470 PyThreadState* __tstate = wxPyBeginAllowThreads();
14471 result = (int)(arg1)->GetManufacturerId();
14472 wxPyEndAllowThreads(__tstate);
14473 if (PyErr_Occurred()) SWIG_fail;
14474 }
14475 resultobj = SWIG_From_int(static_cast< int >(result));
14476 return resultobj;
14477 fail:
14478 return NULL;
14479 }
14480
14481
14482 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14483 PyObject *resultobj = 0;
14484 wxJoystick *arg1 = (wxJoystick *) 0 ;
14485 int result;
14486 void *argp1 = 0 ;
14487 int res1 = 0 ;
14488 PyObject *swig_obj[1] ;
14489
14490 if (!args) SWIG_fail;
14491 swig_obj[0] = args;
14492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14493 if (!SWIG_IsOK(res1)) {
14494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14495 }
14496 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14497 {
14498 PyThreadState* __tstate = wxPyBeginAllowThreads();
14499 result = (int)(arg1)->GetProductId();
14500 wxPyEndAllowThreads(__tstate);
14501 if (PyErr_Occurred()) SWIG_fail;
14502 }
14503 resultobj = SWIG_From_int(static_cast< int >(result));
14504 return resultobj;
14505 fail:
14506 return NULL;
14507 }
14508
14509
14510 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14511 PyObject *resultobj = 0;
14512 wxJoystick *arg1 = (wxJoystick *) 0 ;
14513 wxString result;
14514 void *argp1 = 0 ;
14515 int res1 = 0 ;
14516 PyObject *swig_obj[1] ;
14517
14518 if (!args) SWIG_fail;
14519 swig_obj[0] = args;
14520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14521 if (!SWIG_IsOK(res1)) {
14522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14523 }
14524 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14525 {
14526 PyThreadState* __tstate = wxPyBeginAllowThreads();
14527 result = (arg1)->GetProductName();
14528 wxPyEndAllowThreads(__tstate);
14529 if (PyErr_Occurred()) SWIG_fail;
14530 }
14531 {
14532 #if wxUSE_UNICODE
14533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14534 #else
14535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14536 #endif
14537 }
14538 return resultobj;
14539 fail:
14540 return NULL;
14541 }
14542
14543
14544 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14545 PyObject *resultobj = 0;
14546 wxJoystick *arg1 = (wxJoystick *) 0 ;
14547 int result;
14548 void *argp1 = 0 ;
14549 int res1 = 0 ;
14550 PyObject *swig_obj[1] ;
14551
14552 if (!args) SWIG_fail;
14553 swig_obj[0] = args;
14554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14555 if (!SWIG_IsOK(res1)) {
14556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14557 }
14558 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14559 {
14560 PyThreadState* __tstate = wxPyBeginAllowThreads();
14561 result = (int)(arg1)->GetXMin();
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 resultobj = SWIG_From_int(static_cast< int >(result));
14566 return resultobj;
14567 fail:
14568 return NULL;
14569 }
14570
14571
14572 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14573 PyObject *resultobj = 0;
14574 wxJoystick *arg1 = (wxJoystick *) 0 ;
14575 int result;
14576 void *argp1 = 0 ;
14577 int res1 = 0 ;
14578 PyObject *swig_obj[1] ;
14579
14580 if (!args) SWIG_fail;
14581 swig_obj[0] = args;
14582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14583 if (!SWIG_IsOK(res1)) {
14584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14585 }
14586 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14587 {
14588 PyThreadState* __tstate = wxPyBeginAllowThreads();
14589 result = (int)(arg1)->GetYMin();
14590 wxPyEndAllowThreads(__tstate);
14591 if (PyErr_Occurred()) SWIG_fail;
14592 }
14593 resultobj = SWIG_From_int(static_cast< int >(result));
14594 return resultobj;
14595 fail:
14596 return NULL;
14597 }
14598
14599
14600 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14601 PyObject *resultobj = 0;
14602 wxJoystick *arg1 = (wxJoystick *) 0 ;
14603 int result;
14604 void *argp1 = 0 ;
14605 int res1 = 0 ;
14606 PyObject *swig_obj[1] ;
14607
14608 if (!args) SWIG_fail;
14609 swig_obj[0] = args;
14610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14611 if (!SWIG_IsOK(res1)) {
14612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14613 }
14614 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14615 {
14616 PyThreadState* __tstate = wxPyBeginAllowThreads();
14617 result = (int)(arg1)->GetZMin();
14618 wxPyEndAllowThreads(__tstate);
14619 if (PyErr_Occurred()) SWIG_fail;
14620 }
14621 resultobj = SWIG_From_int(static_cast< int >(result));
14622 return resultobj;
14623 fail:
14624 return NULL;
14625 }
14626
14627
14628 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14629 PyObject *resultobj = 0;
14630 wxJoystick *arg1 = (wxJoystick *) 0 ;
14631 int result;
14632 void *argp1 = 0 ;
14633 int res1 = 0 ;
14634 PyObject *swig_obj[1] ;
14635
14636 if (!args) SWIG_fail;
14637 swig_obj[0] = args;
14638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14639 if (!SWIG_IsOK(res1)) {
14640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14641 }
14642 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14643 {
14644 PyThreadState* __tstate = wxPyBeginAllowThreads();
14645 result = (int)(arg1)->GetXMax();
14646 wxPyEndAllowThreads(__tstate);
14647 if (PyErr_Occurred()) SWIG_fail;
14648 }
14649 resultobj = SWIG_From_int(static_cast< int >(result));
14650 return resultobj;
14651 fail:
14652 return NULL;
14653 }
14654
14655
14656 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14657 PyObject *resultobj = 0;
14658 wxJoystick *arg1 = (wxJoystick *) 0 ;
14659 int result;
14660 void *argp1 = 0 ;
14661 int res1 = 0 ;
14662 PyObject *swig_obj[1] ;
14663
14664 if (!args) SWIG_fail;
14665 swig_obj[0] = args;
14666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14667 if (!SWIG_IsOK(res1)) {
14668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14669 }
14670 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14671 {
14672 PyThreadState* __tstate = wxPyBeginAllowThreads();
14673 result = (int)(arg1)->GetYMax();
14674 wxPyEndAllowThreads(__tstate);
14675 if (PyErr_Occurred()) SWIG_fail;
14676 }
14677 resultobj = SWIG_From_int(static_cast< int >(result));
14678 return resultobj;
14679 fail:
14680 return NULL;
14681 }
14682
14683
14684 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14685 PyObject *resultobj = 0;
14686 wxJoystick *arg1 = (wxJoystick *) 0 ;
14687 int result;
14688 void *argp1 = 0 ;
14689 int res1 = 0 ;
14690 PyObject *swig_obj[1] ;
14691
14692 if (!args) SWIG_fail;
14693 swig_obj[0] = args;
14694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14695 if (!SWIG_IsOK(res1)) {
14696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14697 }
14698 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14699 {
14700 PyThreadState* __tstate = wxPyBeginAllowThreads();
14701 result = (int)(arg1)->GetZMax();
14702 wxPyEndAllowThreads(__tstate);
14703 if (PyErr_Occurred()) SWIG_fail;
14704 }
14705 resultobj = SWIG_From_int(static_cast< int >(result));
14706 return resultobj;
14707 fail:
14708 return NULL;
14709 }
14710
14711
14712 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14713 PyObject *resultobj = 0;
14714 wxJoystick *arg1 = (wxJoystick *) 0 ;
14715 int result;
14716 void *argp1 = 0 ;
14717 int res1 = 0 ;
14718 PyObject *swig_obj[1] ;
14719
14720 if (!args) SWIG_fail;
14721 swig_obj[0] = args;
14722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14723 if (!SWIG_IsOK(res1)) {
14724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14725 }
14726 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14727 {
14728 PyThreadState* __tstate = wxPyBeginAllowThreads();
14729 result = (int)(arg1)->GetNumberButtons();
14730 wxPyEndAllowThreads(__tstate);
14731 if (PyErr_Occurred()) SWIG_fail;
14732 }
14733 resultobj = SWIG_From_int(static_cast< int >(result));
14734 return resultobj;
14735 fail:
14736 return NULL;
14737 }
14738
14739
14740 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14741 PyObject *resultobj = 0;
14742 wxJoystick *arg1 = (wxJoystick *) 0 ;
14743 int result;
14744 void *argp1 = 0 ;
14745 int res1 = 0 ;
14746 PyObject *swig_obj[1] ;
14747
14748 if (!args) SWIG_fail;
14749 swig_obj[0] = args;
14750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14751 if (!SWIG_IsOK(res1)) {
14752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14753 }
14754 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14755 {
14756 PyThreadState* __tstate = wxPyBeginAllowThreads();
14757 result = (int)(arg1)->GetNumberAxes();
14758 wxPyEndAllowThreads(__tstate);
14759 if (PyErr_Occurred()) SWIG_fail;
14760 }
14761 resultobj = SWIG_From_int(static_cast< int >(result));
14762 return resultobj;
14763 fail:
14764 return NULL;
14765 }
14766
14767
14768 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14769 PyObject *resultobj = 0;
14770 wxJoystick *arg1 = (wxJoystick *) 0 ;
14771 int result;
14772 void *argp1 = 0 ;
14773 int res1 = 0 ;
14774 PyObject *swig_obj[1] ;
14775
14776 if (!args) SWIG_fail;
14777 swig_obj[0] = args;
14778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14779 if (!SWIG_IsOK(res1)) {
14780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14781 }
14782 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 result = (int)(arg1)->GetMaxButtons();
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 resultobj = SWIG_From_int(static_cast< int >(result));
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14797 PyObject *resultobj = 0;
14798 wxJoystick *arg1 = (wxJoystick *) 0 ;
14799 int result;
14800 void *argp1 = 0 ;
14801 int res1 = 0 ;
14802 PyObject *swig_obj[1] ;
14803
14804 if (!args) SWIG_fail;
14805 swig_obj[0] = args;
14806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14807 if (!SWIG_IsOK(res1)) {
14808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14809 }
14810 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14811 {
14812 PyThreadState* __tstate = wxPyBeginAllowThreads();
14813 result = (int)(arg1)->GetMaxAxes();
14814 wxPyEndAllowThreads(__tstate);
14815 if (PyErr_Occurred()) SWIG_fail;
14816 }
14817 resultobj = SWIG_From_int(static_cast< int >(result));
14818 return resultobj;
14819 fail:
14820 return NULL;
14821 }
14822
14823
14824 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14825 PyObject *resultobj = 0;
14826 wxJoystick *arg1 = (wxJoystick *) 0 ;
14827 int result;
14828 void *argp1 = 0 ;
14829 int res1 = 0 ;
14830 PyObject *swig_obj[1] ;
14831
14832 if (!args) SWIG_fail;
14833 swig_obj[0] = args;
14834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14837 }
14838 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14839 {
14840 PyThreadState* __tstate = wxPyBeginAllowThreads();
14841 result = (int)(arg1)->GetPollingMin();
14842 wxPyEndAllowThreads(__tstate);
14843 if (PyErr_Occurred()) SWIG_fail;
14844 }
14845 resultobj = SWIG_From_int(static_cast< int >(result));
14846 return resultobj;
14847 fail:
14848 return NULL;
14849 }
14850
14851
14852 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14853 PyObject *resultobj = 0;
14854 wxJoystick *arg1 = (wxJoystick *) 0 ;
14855 int result;
14856 void *argp1 = 0 ;
14857 int res1 = 0 ;
14858 PyObject *swig_obj[1] ;
14859
14860 if (!args) SWIG_fail;
14861 swig_obj[0] = args;
14862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14863 if (!SWIG_IsOK(res1)) {
14864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14865 }
14866 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14867 {
14868 PyThreadState* __tstate = wxPyBeginAllowThreads();
14869 result = (int)(arg1)->GetPollingMax();
14870 wxPyEndAllowThreads(__tstate);
14871 if (PyErr_Occurred()) SWIG_fail;
14872 }
14873 resultobj = SWIG_From_int(static_cast< int >(result));
14874 return resultobj;
14875 fail:
14876 return NULL;
14877 }
14878
14879
14880 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14881 PyObject *resultobj = 0;
14882 wxJoystick *arg1 = (wxJoystick *) 0 ;
14883 int result;
14884 void *argp1 = 0 ;
14885 int res1 = 0 ;
14886 PyObject *swig_obj[1] ;
14887
14888 if (!args) SWIG_fail;
14889 swig_obj[0] = args;
14890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14891 if (!SWIG_IsOK(res1)) {
14892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14893 }
14894 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14895 {
14896 PyThreadState* __tstate = wxPyBeginAllowThreads();
14897 result = (int)(arg1)->GetRudderMin();
14898 wxPyEndAllowThreads(__tstate);
14899 if (PyErr_Occurred()) SWIG_fail;
14900 }
14901 resultobj = SWIG_From_int(static_cast< int >(result));
14902 return resultobj;
14903 fail:
14904 return NULL;
14905 }
14906
14907
14908 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14909 PyObject *resultobj = 0;
14910 wxJoystick *arg1 = (wxJoystick *) 0 ;
14911 int result;
14912 void *argp1 = 0 ;
14913 int res1 = 0 ;
14914 PyObject *swig_obj[1] ;
14915
14916 if (!args) SWIG_fail;
14917 swig_obj[0] = args;
14918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14919 if (!SWIG_IsOK(res1)) {
14920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14921 }
14922 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14923 {
14924 PyThreadState* __tstate = wxPyBeginAllowThreads();
14925 result = (int)(arg1)->GetRudderMax();
14926 wxPyEndAllowThreads(__tstate);
14927 if (PyErr_Occurred()) SWIG_fail;
14928 }
14929 resultobj = SWIG_From_int(static_cast< int >(result));
14930 return resultobj;
14931 fail:
14932 return NULL;
14933 }
14934
14935
14936 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14937 PyObject *resultobj = 0;
14938 wxJoystick *arg1 = (wxJoystick *) 0 ;
14939 int result;
14940 void *argp1 = 0 ;
14941 int res1 = 0 ;
14942 PyObject *swig_obj[1] ;
14943
14944 if (!args) SWIG_fail;
14945 swig_obj[0] = args;
14946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14947 if (!SWIG_IsOK(res1)) {
14948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14949 }
14950 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14951 {
14952 PyThreadState* __tstate = wxPyBeginAllowThreads();
14953 result = (int)(arg1)->GetUMin();
14954 wxPyEndAllowThreads(__tstate);
14955 if (PyErr_Occurred()) SWIG_fail;
14956 }
14957 resultobj = SWIG_From_int(static_cast< int >(result));
14958 return resultobj;
14959 fail:
14960 return NULL;
14961 }
14962
14963
14964 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14965 PyObject *resultobj = 0;
14966 wxJoystick *arg1 = (wxJoystick *) 0 ;
14967 int result;
14968 void *argp1 = 0 ;
14969 int res1 = 0 ;
14970 PyObject *swig_obj[1] ;
14971
14972 if (!args) SWIG_fail;
14973 swig_obj[0] = args;
14974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14975 if (!SWIG_IsOK(res1)) {
14976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14977 }
14978 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14979 {
14980 PyThreadState* __tstate = wxPyBeginAllowThreads();
14981 result = (int)(arg1)->GetUMax();
14982 wxPyEndAllowThreads(__tstate);
14983 if (PyErr_Occurred()) SWIG_fail;
14984 }
14985 resultobj = SWIG_From_int(static_cast< int >(result));
14986 return resultobj;
14987 fail:
14988 return NULL;
14989 }
14990
14991
14992 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14993 PyObject *resultobj = 0;
14994 wxJoystick *arg1 = (wxJoystick *) 0 ;
14995 int result;
14996 void *argp1 = 0 ;
14997 int res1 = 0 ;
14998 PyObject *swig_obj[1] ;
14999
15000 if (!args) SWIG_fail;
15001 swig_obj[0] = args;
15002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15003 if (!SWIG_IsOK(res1)) {
15004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15005 }
15006 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15007 {
15008 PyThreadState* __tstate = wxPyBeginAllowThreads();
15009 result = (int)(arg1)->GetVMin();
15010 wxPyEndAllowThreads(__tstate);
15011 if (PyErr_Occurred()) SWIG_fail;
15012 }
15013 resultobj = SWIG_From_int(static_cast< int >(result));
15014 return resultobj;
15015 fail:
15016 return NULL;
15017 }
15018
15019
15020 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15021 PyObject *resultobj = 0;
15022 wxJoystick *arg1 = (wxJoystick *) 0 ;
15023 int result;
15024 void *argp1 = 0 ;
15025 int res1 = 0 ;
15026 PyObject *swig_obj[1] ;
15027
15028 if (!args) SWIG_fail;
15029 swig_obj[0] = args;
15030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15031 if (!SWIG_IsOK(res1)) {
15032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15033 }
15034 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15035 {
15036 PyThreadState* __tstate = wxPyBeginAllowThreads();
15037 result = (int)(arg1)->GetVMax();
15038 wxPyEndAllowThreads(__tstate);
15039 if (PyErr_Occurred()) SWIG_fail;
15040 }
15041 resultobj = SWIG_From_int(static_cast< int >(result));
15042 return resultobj;
15043 fail:
15044 return NULL;
15045 }
15046
15047
15048 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15049 PyObject *resultobj = 0;
15050 wxJoystick *arg1 = (wxJoystick *) 0 ;
15051 bool result;
15052 void *argp1 = 0 ;
15053 int res1 = 0 ;
15054 PyObject *swig_obj[1] ;
15055
15056 if (!args) SWIG_fail;
15057 swig_obj[0] = args;
15058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15059 if (!SWIG_IsOK(res1)) {
15060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
15061 }
15062 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15063 {
15064 PyThreadState* __tstate = wxPyBeginAllowThreads();
15065 result = (bool)(arg1)->HasRudder();
15066 wxPyEndAllowThreads(__tstate);
15067 if (PyErr_Occurred()) SWIG_fail;
15068 }
15069 {
15070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15071 }
15072 return resultobj;
15073 fail:
15074 return NULL;
15075 }
15076
15077
15078 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15079 PyObject *resultobj = 0;
15080 wxJoystick *arg1 = (wxJoystick *) 0 ;
15081 bool result;
15082 void *argp1 = 0 ;
15083 int res1 = 0 ;
15084 PyObject *swig_obj[1] ;
15085
15086 if (!args) SWIG_fail;
15087 swig_obj[0] = args;
15088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15089 if (!SWIG_IsOK(res1)) {
15090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
15091 }
15092 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15093 {
15094 PyThreadState* __tstate = wxPyBeginAllowThreads();
15095 result = (bool)(arg1)->HasZ();
15096 wxPyEndAllowThreads(__tstate);
15097 if (PyErr_Occurred()) SWIG_fail;
15098 }
15099 {
15100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15101 }
15102 return resultobj;
15103 fail:
15104 return NULL;
15105 }
15106
15107
15108 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15109 PyObject *resultobj = 0;
15110 wxJoystick *arg1 = (wxJoystick *) 0 ;
15111 bool result;
15112 void *argp1 = 0 ;
15113 int res1 = 0 ;
15114 PyObject *swig_obj[1] ;
15115
15116 if (!args) SWIG_fail;
15117 swig_obj[0] = args;
15118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15119 if (!SWIG_IsOK(res1)) {
15120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
15121 }
15122 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15123 {
15124 PyThreadState* __tstate = wxPyBeginAllowThreads();
15125 result = (bool)(arg1)->HasU();
15126 wxPyEndAllowThreads(__tstate);
15127 if (PyErr_Occurred()) SWIG_fail;
15128 }
15129 {
15130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15131 }
15132 return resultobj;
15133 fail:
15134 return NULL;
15135 }
15136
15137
15138 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15139 PyObject *resultobj = 0;
15140 wxJoystick *arg1 = (wxJoystick *) 0 ;
15141 bool result;
15142 void *argp1 = 0 ;
15143 int res1 = 0 ;
15144 PyObject *swig_obj[1] ;
15145
15146 if (!args) SWIG_fail;
15147 swig_obj[0] = args;
15148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15149 if (!SWIG_IsOK(res1)) {
15150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15151 }
15152 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15153 {
15154 PyThreadState* __tstate = wxPyBeginAllowThreads();
15155 result = (bool)(arg1)->HasV();
15156 wxPyEndAllowThreads(__tstate);
15157 if (PyErr_Occurred()) SWIG_fail;
15158 }
15159 {
15160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15161 }
15162 return resultobj;
15163 fail:
15164 return NULL;
15165 }
15166
15167
15168 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15169 PyObject *resultobj = 0;
15170 wxJoystick *arg1 = (wxJoystick *) 0 ;
15171 bool result;
15172 void *argp1 = 0 ;
15173 int res1 = 0 ;
15174 PyObject *swig_obj[1] ;
15175
15176 if (!args) SWIG_fail;
15177 swig_obj[0] = args;
15178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15179 if (!SWIG_IsOK(res1)) {
15180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15181 }
15182 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15183 {
15184 PyThreadState* __tstate = wxPyBeginAllowThreads();
15185 result = (bool)(arg1)->HasPOV();
15186 wxPyEndAllowThreads(__tstate);
15187 if (PyErr_Occurred()) SWIG_fail;
15188 }
15189 {
15190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15191 }
15192 return resultobj;
15193 fail:
15194 return NULL;
15195 }
15196
15197
15198 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15199 PyObject *resultobj = 0;
15200 wxJoystick *arg1 = (wxJoystick *) 0 ;
15201 bool result;
15202 void *argp1 = 0 ;
15203 int res1 = 0 ;
15204 PyObject *swig_obj[1] ;
15205
15206 if (!args) SWIG_fail;
15207 swig_obj[0] = args;
15208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15209 if (!SWIG_IsOK(res1)) {
15210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15211 }
15212 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15213 {
15214 PyThreadState* __tstate = wxPyBeginAllowThreads();
15215 result = (bool)(arg1)->HasPOV4Dir();
15216 wxPyEndAllowThreads(__tstate);
15217 if (PyErr_Occurred()) SWIG_fail;
15218 }
15219 {
15220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15221 }
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15229 PyObject *resultobj = 0;
15230 wxJoystick *arg1 = (wxJoystick *) 0 ;
15231 bool result;
15232 void *argp1 = 0 ;
15233 int res1 = 0 ;
15234 PyObject *swig_obj[1] ;
15235
15236 if (!args) SWIG_fail;
15237 swig_obj[0] = args;
15238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15239 if (!SWIG_IsOK(res1)) {
15240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15241 }
15242 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15243 {
15244 PyThreadState* __tstate = wxPyBeginAllowThreads();
15245 result = (bool)(arg1)->HasPOVCTS();
15246 wxPyEndAllowThreads(__tstate);
15247 if (PyErr_Occurred()) SWIG_fail;
15248 }
15249 {
15250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15251 }
15252 return resultobj;
15253 fail:
15254 return NULL;
15255 }
15256
15257
15258 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj = 0;
15260 wxJoystick *arg1 = (wxJoystick *) 0 ;
15261 wxWindow *arg2 = (wxWindow *) 0 ;
15262 int arg3 = (int) 0 ;
15263 bool result;
15264 void *argp1 = 0 ;
15265 int res1 = 0 ;
15266 void *argp2 = 0 ;
15267 int res2 = 0 ;
15268 int val3 ;
15269 int ecode3 = 0 ;
15270 PyObject * obj0 = 0 ;
15271 PyObject * obj1 = 0 ;
15272 PyObject * obj2 = 0 ;
15273 char * kwnames[] = {
15274 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15275 };
15276
15277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15279 if (!SWIG_IsOK(res1)) {
15280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15281 }
15282 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15284 if (!SWIG_IsOK(res2)) {
15285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15286 }
15287 arg2 = reinterpret_cast< wxWindow * >(argp2);
15288 if (obj2) {
15289 ecode3 = SWIG_AsVal_int(obj2, &val3);
15290 if (!SWIG_IsOK(ecode3)) {
15291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15292 }
15293 arg3 = static_cast< int >(val3);
15294 }
15295 {
15296 PyThreadState* __tstate = wxPyBeginAllowThreads();
15297 result = (bool)(arg1)->SetCapture(arg2,arg3);
15298 wxPyEndAllowThreads(__tstate);
15299 if (PyErr_Occurred()) SWIG_fail;
15300 }
15301 {
15302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15303 }
15304 return resultobj;
15305 fail:
15306 return NULL;
15307 }
15308
15309
15310 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15311 PyObject *resultobj = 0;
15312 wxJoystick *arg1 = (wxJoystick *) 0 ;
15313 bool result;
15314 void *argp1 = 0 ;
15315 int res1 = 0 ;
15316 PyObject *swig_obj[1] ;
15317
15318 if (!args) SWIG_fail;
15319 swig_obj[0] = args;
15320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15321 if (!SWIG_IsOK(res1)) {
15322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15323 }
15324 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15325 {
15326 PyThreadState* __tstate = wxPyBeginAllowThreads();
15327 result = (bool)(arg1)->ReleaseCapture();
15328 wxPyEndAllowThreads(__tstate);
15329 if (PyErr_Occurred()) SWIG_fail;
15330 }
15331 {
15332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15333 }
15334 return resultobj;
15335 fail:
15336 return NULL;
15337 }
15338
15339
15340 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15341 PyObject *obj;
15342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15343 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15344 return SWIG_Py_Void();
15345 }
15346
15347 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15348 return SWIG_Python_InitShadowInstance(args);
15349 }
15350
15351 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15352 PyObject *resultobj = 0;
15353 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15354 int arg2 = (int) 0 ;
15355 int arg3 = (int) wxJOYSTICK1 ;
15356 int arg4 = (int) 0 ;
15357 wxJoystickEvent *result = 0 ;
15358 int val1 ;
15359 int ecode1 = 0 ;
15360 int val2 ;
15361 int ecode2 = 0 ;
15362 int val3 ;
15363 int ecode3 = 0 ;
15364 int val4 ;
15365 int ecode4 = 0 ;
15366 PyObject * obj0 = 0 ;
15367 PyObject * obj1 = 0 ;
15368 PyObject * obj2 = 0 ;
15369 PyObject * obj3 = 0 ;
15370 char * kwnames[] = {
15371 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15372 };
15373
15374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15375 if (obj0) {
15376 ecode1 = SWIG_AsVal_int(obj0, &val1);
15377 if (!SWIG_IsOK(ecode1)) {
15378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15379 }
15380 arg1 = static_cast< wxEventType >(val1);
15381 }
15382 if (obj1) {
15383 ecode2 = SWIG_AsVal_int(obj1, &val2);
15384 if (!SWIG_IsOK(ecode2)) {
15385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15386 }
15387 arg2 = static_cast< int >(val2);
15388 }
15389 if (obj2) {
15390 ecode3 = SWIG_AsVal_int(obj2, &val3);
15391 if (!SWIG_IsOK(ecode3)) {
15392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15393 }
15394 arg3 = static_cast< int >(val3);
15395 }
15396 if (obj3) {
15397 ecode4 = SWIG_AsVal_int(obj3, &val4);
15398 if (!SWIG_IsOK(ecode4)) {
15399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15400 }
15401 arg4 = static_cast< int >(val4);
15402 }
15403 {
15404 PyThreadState* __tstate = wxPyBeginAllowThreads();
15405 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15406 wxPyEndAllowThreads(__tstate);
15407 if (PyErr_Occurred()) SWIG_fail;
15408 }
15409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15410 return resultobj;
15411 fail:
15412 return NULL;
15413 }
15414
15415
15416 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15417 PyObject *resultobj = 0;
15418 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15419 wxPoint result;
15420 void *argp1 = 0 ;
15421 int res1 = 0 ;
15422 PyObject *swig_obj[1] ;
15423
15424 if (!args) SWIG_fail;
15425 swig_obj[0] = args;
15426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15427 if (!SWIG_IsOK(res1)) {
15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15429 }
15430 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15431 {
15432 PyThreadState* __tstate = wxPyBeginAllowThreads();
15433 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15434 wxPyEndAllowThreads(__tstate);
15435 if (PyErr_Occurred()) SWIG_fail;
15436 }
15437 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15438 return resultobj;
15439 fail:
15440 return NULL;
15441 }
15442
15443
15444 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15445 PyObject *resultobj = 0;
15446 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15447 int result;
15448 void *argp1 = 0 ;
15449 int res1 = 0 ;
15450 PyObject *swig_obj[1] ;
15451
15452 if (!args) SWIG_fail;
15453 swig_obj[0] = args;
15454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15455 if (!SWIG_IsOK(res1)) {
15456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15457 }
15458 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15459 {
15460 PyThreadState* __tstate = wxPyBeginAllowThreads();
15461 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15462 wxPyEndAllowThreads(__tstate);
15463 if (PyErr_Occurred()) SWIG_fail;
15464 }
15465 resultobj = SWIG_From_int(static_cast< int >(result));
15466 return resultobj;
15467 fail:
15468 return NULL;
15469 }
15470
15471
15472 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15473 PyObject *resultobj = 0;
15474 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15475 int result;
15476 void *argp1 = 0 ;
15477 int res1 = 0 ;
15478 PyObject *swig_obj[1] ;
15479
15480 if (!args) SWIG_fail;
15481 swig_obj[0] = args;
15482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15483 if (!SWIG_IsOK(res1)) {
15484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15485 }
15486 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15487 {
15488 PyThreadState* __tstate = wxPyBeginAllowThreads();
15489 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15490 wxPyEndAllowThreads(__tstate);
15491 if (PyErr_Occurred()) SWIG_fail;
15492 }
15493 resultobj = SWIG_From_int(static_cast< int >(result));
15494 return resultobj;
15495 fail:
15496 return NULL;
15497 }
15498
15499
15500 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15501 PyObject *resultobj = 0;
15502 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15503 int result;
15504 void *argp1 = 0 ;
15505 int res1 = 0 ;
15506 PyObject *swig_obj[1] ;
15507
15508 if (!args) SWIG_fail;
15509 swig_obj[0] = args;
15510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15511 if (!SWIG_IsOK(res1)) {
15512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15513 }
15514 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15515 {
15516 PyThreadState* __tstate = wxPyBeginAllowThreads();
15517 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15518 wxPyEndAllowThreads(__tstate);
15519 if (PyErr_Occurred()) SWIG_fail;
15520 }
15521 resultobj = SWIG_From_int(static_cast< int >(result));
15522 return resultobj;
15523 fail:
15524 return NULL;
15525 }
15526
15527
15528 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15529 PyObject *resultobj = 0;
15530 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15531 int result;
15532 void *argp1 = 0 ;
15533 int res1 = 0 ;
15534 PyObject *swig_obj[1] ;
15535
15536 if (!args) SWIG_fail;
15537 swig_obj[0] = args;
15538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15539 if (!SWIG_IsOK(res1)) {
15540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15541 }
15542 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15546 wxPyEndAllowThreads(__tstate);
15547 if (PyErr_Occurred()) SWIG_fail;
15548 }
15549 resultobj = SWIG_From_int(static_cast< int >(result));
15550 return resultobj;
15551 fail:
15552 return NULL;
15553 }
15554
15555
15556 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15557 PyObject *resultobj = 0;
15558 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15559 int arg2 ;
15560 void *argp1 = 0 ;
15561 int res1 = 0 ;
15562 int val2 ;
15563 int ecode2 = 0 ;
15564 PyObject * obj0 = 0 ;
15565 PyObject * obj1 = 0 ;
15566 char * kwnames[] = {
15567 (char *) "self",(char *) "stick", NULL
15568 };
15569
15570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15572 if (!SWIG_IsOK(res1)) {
15573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15574 }
15575 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15576 ecode2 = SWIG_AsVal_int(obj1, &val2);
15577 if (!SWIG_IsOK(ecode2)) {
15578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15579 }
15580 arg2 = static_cast< int >(val2);
15581 {
15582 PyThreadState* __tstate = wxPyBeginAllowThreads();
15583 (arg1)->SetJoystick(arg2);
15584 wxPyEndAllowThreads(__tstate);
15585 if (PyErr_Occurred()) SWIG_fail;
15586 }
15587 resultobj = SWIG_Py_Void();
15588 return resultobj;
15589 fail:
15590 return NULL;
15591 }
15592
15593
15594 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15595 PyObject *resultobj = 0;
15596 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15597 int arg2 ;
15598 void *argp1 = 0 ;
15599 int res1 = 0 ;
15600 int val2 ;
15601 int ecode2 = 0 ;
15602 PyObject * obj0 = 0 ;
15603 PyObject * obj1 = 0 ;
15604 char * kwnames[] = {
15605 (char *) "self",(char *) "state", NULL
15606 };
15607
15608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15610 if (!SWIG_IsOK(res1)) {
15611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15612 }
15613 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15614 ecode2 = SWIG_AsVal_int(obj1, &val2);
15615 if (!SWIG_IsOK(ecode2)) {
15616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15617 }
15618 arg2 = static_cast< int >(val2);
15619 {
15620 PyThreadState* __tstate = wxPyBeginAllowThreads();
15621 (arg1)->SetButtonState(arg2);
15622 wxPyEndAllowThreads(__tstate);
15623 if (PyErr_Occurred()) SWIG_fail;
15624 }
15625 resultobj = SWIG_Py_Void();
15626 return resultobj;
15627 fail:
15628 return NULL;
15629 }
15630
15631
15632 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15633 PyObject *resultobj = 0;
15634 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15635 int arg2 ;
15636 void *argp1 = 0 ;
15637 int res1 = 0 ;
15638 int val2 ;
15639 int ecode2 = 0 ;
15640 PyObject * obj0 = 0 ;
15641 PyObject * obj1 = 0 ;
15642 char * kwnames[] = {
15643 (char *) "self",(char *) "change", NULL
15644 };
15645
15646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15648 if (!SWIG_IsOK(res1)) {
15649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15650 }
15651 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15652 ecode2 = SWIG_AsVal_int(obj1, &val2);
15653 if (!SWIG_IsOK(ecode2)) {
15654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15655 }
15656 arg2 = static_cast< int >(val2);
15657 {
15658 PyThreadState* __tstate = wxPyBeginAllowThreads();
15659 (arg1)->SetButtonChange(arg2);
15660 wxPyEndAllowThreads(__tstate);
15661 if (PyErr_Occurred()) SWIG_fail;
15662 }
15663 resultobj = SWIG_Py_Void();
15664 return resultobj;
15665 fail:
15666 return NULL;
15667 }
15668
15669
15670 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15671 PyObject *resultobj = 0;
15672 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15673 wxPoint *arg2 = 0 ;
15674 void *argp1 = 0 ;
15675 int res1 = 0 ;
15676 wxPoint temp2 ;
15677 PyObject * obj0 = 0 ;
15678 PyObject * obj1 = 0 ;
15679 char * kwnames[] = {
15680 (char *) "self",(char *) "pos", NULL
15681 };
15682
15683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15685 if (!SWIG_IsOK(res1)) {
15686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15687 }
15688 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15689 {
15690 arg2 = &temp2;
15691 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15692 }
15693 {
15694 PyThreadState* __tstate = wxPyBeginAllowThreads();
15695 (arg1)->SetPosition((wxPoint const &)*arg2);
15696 wxPyEndAllowThreads(__tstate);
15697 if (PyErr_Occurred()) SWIG_fail;
15698 }
15699 resultobj = SWIG_Py_Void();
15700 return resultobj;
15701 fail:
15702 return NULL;
15703 }
15704
15705
15706 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15707 PyObject *resultobj = 0;
15708 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15709 int arg2 ;
15710 void *argp1 = 0 ;
15711 int res1 = 0 ;
15712 int val2 ;
15713 int ecode2 = 0 ;
15714 PyObject * obj0 = 0 ;
15715 PyObject * obj1 = 0 ;
15716 char * kwnames[] = {
15717 (char *) "self",(char *) "zPos", NULL
15718 };
15719
15720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15722 if (!SWIG_IsOK(res1)) {
15723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15724 }
15725 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15726 ecode2 = SWIG_AsVal_int(obj1, &val2);
15727 if (!SWIG_IsOK(ecode2)) {
15728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15729 }
15730 arg2 = static_cast< int >(val2);
15731 {
15732 PyThreadState* __tstate = wxPyBeginAllowThreads();
15733 (arg1)->SetZPosition(arg2);
15734 wxPyEndAllowThreads(__tstate);
15735 if (PyErr_Occurred()) SWIG_fail;
15736 }
15737 resultobj = SWIG_Py_Void();
15738 return resultobj;
15739 fail:
15740 return NULL;
15741 }
15742
15743
15744 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15745 PyObject *resultobj = 0;
15746 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15747 bool result;
15748 void *argp1 = 0 ;
15749 int res1 = 0 ;
15750 PyObject *swig_obj[1] ;
15751
15752 if (!args) SWIG_fail;
15753 swig_obj[0] = args;
15754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15755 if (!SWIG_IsOK(res1)) {
15756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15757 }
15758 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15762 wxPyEndAllowThreads(__tstate);
15763 if (PyErr_Occurred()) SWIG_fail;
15764 }
15765 {
15766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15767 }
15768 return resultobj;
15769 fail:
15770 return NULL;
15771 }
15772
15773
15774 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15775 PyObject *resultobj = 0;
15776 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15777 bool result;
15778 void *argp1 = 0 ;
15779 int res1 = 0 ;
15780 PyObject *swig_obj[1] ;
15781
15782 if (!args) SWIG_fail;
15783 swig_obj[0] = args;
15784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15785 if (!SWIG_IsOK(res1)) {
15786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15787 }
15788 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15792 wxPyEndAllowThreads(__tstate);
15793 if (PyErr_Occurred()) SWIG_fail;
15794 }
15795 {
15796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15797 }
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15805 PyObject *resultobj = 0;
15806 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15807 bool result;
15808 void *argp1 = 0 ;
15809 int res1 = 0 ;
15810 PyObject *swig_obj[1] ;
15811
15812 if (!args) SWIG_fail;
15813 swig_obj[0] = args;
15814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15815 if (!SWIG_IsOK(res1)) {
15816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15817 }
15818 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15819 {
15820 PyThreadState* __tstate = wxPyBeginAllowThreads();
15821 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15822 wxPyEndAllowThreads(__tstate);
15823 if (PyErr_Occurred()) SWIG_fail;
15824 }
15825 {
15826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15827 }
15828 return resultobj;
15829 fail:
15830 return NULL;
15831 }
15832
15833
15834 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15835 PyObject *resultobj = 0;
15836 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15837 int arg2 = (int) wxJOY_BUTTON_ANY ;
15838 bool result;
15839 void *argp1 = 0 ;
15840 int res1 = 0 ;
15841 int val2 ;
15842 int ecode2 = 0 ;
15843 PyObject * obj0 = 0 ;
15844 PyObject * obj1 = 0 ;
15845 char * kwnames[] = {
15846 (char *) "self",(char *) "but", NULL
15847 };
15848
15849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15851 if (!SWIG_IsOK(res1)) {
15852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15853 }
15854 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15855 if (obj1) {
15856 ecode2 = SWIG_AsVal_int(obj1, &val2);
15857 if (!SWIG_IsOK(ecode2)) {
15858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15859 }
15860 arg2 = static_cast< int >(val2);
15861 }
15862 {
15863 PyThreadState* __tstate = wxPyBeginAllowThreads();
15864 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15865 wxPyEndAllowThreads(__tstate);
15866 if (PyErr_Occurred()) SWIG_fail;
15867 }
15868 {
15869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15870 }
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15878 PyObject *resultobj = 0;
15879 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15880 int arg2 = (int) wxJOY_BUTTON_ANY ;
15881 bool result;
15882 void *argp1 = 0 ;
15883 int res1 = 0 ;
15884 int val2 ;
15885 int ecode2 = 0 ;
15886 PyObject * obj0 = 0 ;
15887 PyObject * obj1 = 0 ;
15888 char * kwnames[] = {
15889 (char *) "self",(char *) "but", NULL
15890 };
15891
15892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15894 if (!SWIG_IsOK(res1)) {
15895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15896 }
15897 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15898 if (obj1) {
15899 ecode2 = SWIG_AsVal_int(obj1, &val2);
15900 if (!SWIG_IsOK(ecode2)) {
15901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15902 }
15903 arg2 = static_cast< int >(val2);
15904 }
15905 {
15906 PyThreadState* __tstate = wxPyBeginAllowThreads();
15907 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15908 wxPyEndAllowThreads(__tstate);
15909 if (PyErr_Occurred()) SWIG_fail;
15910 }
15911 {
15912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15913 }
15914 return resultobj;
15915 fail:
15916 return NULL;
15917 }
15918
15919
15920 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15921 PyObject *resultobj = 0;
15922 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15923 int arg2 = (int) wxJOY_BUTTON_ANY ;
15924 bool result;
15925 void *argp1 = 0 ;
15926 int res1 = 0 ;
15927 int val2 ;
15928 int ecode2 = 0 ;
15929 PyObject * obj0 = 0 ;
15930 PyObject * obj1 = 0 ;
15931 char * kwnames[] = {
15932 (char *) "self",(char *) "but", NULL
15933 };
15934
15935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15937 if (!SWIG_IsOK(res1)) {
15938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15939 }
15940 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15941 if (obj1) {
15942 ecode2 = SWIG_AsVal_int(obj1, &val2);
15943 if (!SWIG_IsOK(ecode2)) {
15944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15945 }
15946 arg2 = static_cast< int >(val2);
15947 }
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 {
15955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15956 }
15957 return resultobj;
15958 fail:
15959 return NULL;
15960 }
15961
15962
15963 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15964 PyObject *obj;
15965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15966 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15967 return SWIG_Py_Void();
15968 }
15969
15970 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15971 return SWIG_Python_InitShadowInstance(args);
15972 }
15973
15974 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15975 PyObject *resultobj = 0;
15976 wxString const &arg1_defvalue = wxPyEmptyString ;
15977 wxString *arg1 = (wxString *) &arg1_defvalue ;
15978 wxSound *result = 0 ;
15979 bool temp1 = false ;
15980 PyObject * obj0 = 0 ;
15981 char * kwnames[] = {
15982 (char *) "fileName", NULL
15983 };
15984
15985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15986 if (obj0) {
15987 {
15988 arg1 = wxString_in_helper(obj0);
15989 if (arg1 == NULL) SWIG_fail;
15990 temp1 = true;
15991 }
15992 }
15993 {
15994 if (!wxPyCheckForApp()) SWIG_fail;
15995 PyThreadState* __tstate = wxPyBeginAllowThreads();
15996 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15997 wxPyEndAllowThreads(__tstate);
15998 if (PyErr_Occurred()) SWIG_fail;
15999 }
16000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
16001 {
16002 if (temp1)
16003 delete arg1;
16004 }
16005 return resultobj;
16006 fail:
16007 {
16008 if (temp1)
16009 delete arg1;
16010 }
16011 return NULL;
16012 }
16013
16014
16015 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16016 PyObject *resultobj = 0;
16017 PyObject *arg1 = (PyObject *) 0 ;
16018 wxSound *result = 0 ;
16019 PyObject * obj0 = 0 ;
16020 char * kwnames[] = {
16021 (char *) "data", NULL
16022 };
16023
16024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
16025 arg1 = obj0;
16026 {
16027 if (!wxPyCheckForApp()) SWIG_fail;
16028 PyThreadState* __tstate = wxPyBeginAllowThreads();
16029 result = (wxSound *)new_wxSound(arg1);
16030 wxPyEndAllowThreads(__tstate);
16031 if (PyErr_Occurred()) SWIG_fail;
16032 }
16033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
16034 return resultobj;
16035 fail:
16036 return NULL;
16037 }
16038
16039
16040 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16041 PyObject *resultobj = 0;
16042 wxSound *arg1 = (wxSound *) 0 ;
16043 void *argp1 = 0 ;
16044 int res1 = 0 ;
16045 PyObject *swig_obj[1] ;
16046
16047 if (!args) SWIG_fail;
16048 swig_obj[0] = args;
16049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
16050 if (!SWIG_IsOK(res1)) {
16051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
16052 }
16053 arg1 = reinterpret_cast< wxSound * >(argp1);
16054 {
16055 PyThreadState* __tstate = wxPyBeginAllowThreads();
16056 delete arg1;
16057
16058 wxPyEndAllowThreads(__tstate);
16059 if (PyErr_Occurred()) SWIG_fail;
16060 }
16061 resultobj = SWIG_Py_Void();
16062 return resultobj;
16063 fail:
16064 return NULL;
16065 }
16066
16067
16068 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16069 PyObject *resultobj = 0;
16070 wxSound *arg1 = (wxSound *) 0 ;
16071 wxString *arg2 = 0 ;
16072 bool result;
16073 void *argp1 = 0 ;
16074 int res1 = 0 ;
16075 bool temp2 = false ;
16076 PyObject * obj0 = 0 ;
16077 PyObject * obj1 = 0 ;
16078 char * kwnames[] = {
16079 (char *) "self",(char *) "fileName", NULL
16080 };
16081
16082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
16083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16084 if (!SWIG_IsOK(res1)) {
16085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
16086 }
16087 arg1 = reinterpret_cast< wxSound * >(argp1);
16088 {
16089 arg2 = wxString_in_helper(obj1);
16090 if (arg2 == NULL) SWIG_fail;
16091 temp2 = true;
16092 }
16093 {
16094 PyThreadState* __tstate = wxPyBeginAllowThreads();
16095 result = (bool)(arg1)->Create((wxString const &)*arg2);
16096 wxPyEndAllowThreads(__tstate);
16097 if (PyErr_Occurred()) SWIG_fail;
16098 }
16099 {
16100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16101 }
16102 {
16103 if (temp2)
16104 delete arg2;
16105 }
16106 return resultobj;
16107 fail:
16108 {
16109 if (temp2)
16110 delete arg2;
16111 }
16112 return NULL;
16113 }
16114
16115
16116 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16117 PyObject *resultobj = 0;
16118 wxSound *arg1 = (wxSound *) 0 ;
16119 PyObject *arg2 = (PyObject *) 0 ;
16120 bool result;
16121 void *argp1 = 0 ;
16122 int res1 = 0 ;
16123 PyObject * obj0 = 0 ;
16124 PyObject * obj1 = 0 ;
16125 char * kwnames[] = {
16126 (char *) "self",(char *) "data", NULL
16127 };
16128
16129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16131 if (!SWIG_IsOK(res1)) {
16132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16133 }
16134 arg1 = reinterpret_cast< wxSound * >(argp1);
16135 arg2 = obj1;
16136 {
16137 PyThreadState* __tstate = wxPyBeginAllowThreads();
16138 result = (bool)wxSound_CreateFromData(arg1,arg2);
16139 wxPyEndAllowThreads(__tstate);
16140 if (PyErr_Occurred()) SWIG_fail;
16141 }
16142 {
16143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16144 }
16145 return resultobj;
16146 fail:
16147 return NULL;
16148 }
16149
16150
16151 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16152 PyObject *resultobj = 0;
16153 wxSound *arg1 = (wxSound *) 0 ;
16154 bool result;
16155 void *argp1 = 0 ;
16156 int res1 = 0 ;
16157 PyObject *swig_obj[1] ;
16158
16159 if (!args) SWIG_fail;
16160 swig_obj[0] = args;
16161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16162 if (!SWIG_IsOK(res1)) {
16163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16164 }
16165 arg1 = reinterpret_cast< wxSound * >(argp1);
16166 {
16167 PyThreadState* __tstate = wxPyBeginAllowThreads();
16168 result = (bool)(arg1)->IsOk();
16169 wxPyEndAllowThreads(__tstate);
16170 if (PyErr_Occurred()) SWIG_fail;
16171 }
16172 {
16173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16174 }
16175 return resultobj;
16176 fail:
16177 return NULL;
16178 }
16179
16180
16181 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16182 PyObject *resultobj = 0;
16183 wxSound *arg1 = (wxSound *) 0 ;
16184 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16185 bool result;
16186 void *argp1 = 0 ;
16187 int res1 = 0 ;
16188 unsigned int val2 ;
16189 int ecode2 = 0 ;
16190 PyObject * obj0 = 0 ;
16191 PyObject * obj1 = 0 ;
16192 char * kwnames[] = {
16193 (char *) "self",(char *) "flags", NULL
16194 };
16195
16196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16198 if (!SWIG_IsOK(res1)) {
16199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16200 }
16201 arg1 = reinterpret_cast< wxSound * >(argp1);
16202 if (obj1) {
16203 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16204 if (!SWIG_IsOK(ecode2)) {
16205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16206 }
16207 arg2 = static_cast< unsigned int >(val2);
16208 }
16209 {
16210 if (!wxPyCheckForApp()) SWIG_fail;
16211 PyThreadState* __tstate = wxPyBeginAllowThreads();
16212 result = (bool)((wxSound const *)arg1)->Play(arg2);
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 {
16217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16218 }
16219 return resultobj;
16220 fail:
16221 return NULL;
16222 }
16223
16224
16225 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16226 PyObject *resultobj = 0;
16227 wxString *arg1 = 0 ;
16228 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16229 bool result;
16230 bool temp1 = false ;
16231 unsigned int val2 ;
16232 int ecode2 = 0 ;
16233 PyObject * obj0 = 0 ;
16234 PyObject * obj1 = 0 ;
16235 char * kwnames[] = {
16236 (char *) "filename",(char *) "flags", NULL
16237 };
16238
16239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16240 {
16241 arg1 = wxString_in_helper(obj0);
16242 if (arg1 == NULL) SWIG_fail;
16243 temp1 = true;
16244 }
16245 if (obj1) {
16246 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16247 if (!SWIG_IsOK(ecode2)) {
16248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16249 }
16250 arg2 = static_cast< unsigned int >(val2);
16251 }
16252 {
16253 if (!wxPyCheckForApp()) SWIG_fail;
16254 PyThreadState* __tstate = wxPyBeginAllowThreads();
16255 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16256 wxPyEndAllowThreads(__tstate);
16257 if (PyErr_Occurred()) SWIG_fail;
16258 }
16259 {
16260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16261 }
16262 {
16263 if (temp1)
16264 delete arg1;
16265 }
16266 return resultobj;
16267 fail:
16268 {
16269 if (temp1)
16270 delete arg1;
16271 }
16272 return NULL;
16273 }
16274
16275
16276 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16277 PyObject *resultobj = 0;
16278
16279 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16280 {
16281 if (!wxPyCheckForApp()) SWIG_fail;
16282 PyThreadState* __tstate = wxPyBeginAllowThreads();
16283 wxSound::Stop();
16284 wxPyEndAllowThreads(__tstate);
16285 if (PyErr_Occurred()) SWIG_fail;
16286 }
16287 resultobj = SWIG_Py_Void();
16288 return resultobj;
16289 fail:
16290 return NULL;
16291 }
16292
16293
16294 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16295 PyObject *obj;
16296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16297 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16298 return SWIG_Py_Void();
16299 }
16300
16301 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16302 return SWIG_Python_InitShadowInstance(args);
16303 }
16304
16305 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16306 PyObject *resultobj = 0;
16307 wxString *arg1 = 0 ;
16308 wxString *arg2 = 0 ;
16309 wxString *arg3 = 0 ;
16310 wxString *arg4 = 0 ;
16311 wxFileTypeInfo *result = 0 ;
16312 bool temp1 = false ;
16313 bool temp2 = false ;
16314 bool temp3 = false ;
16315 bool temp4 = false ;
16316 PyObject * obj0 = 0 ;
16317 PyObject * obj1 = 0 ;
16318 PyObject * obj2 = 0 ;
16319 PyObject * obj3 = 0 ;
16320 char * kwnames[] = {
16321 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16322 };
16323
16324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16325 {
16326 arg1 = wxString_in_helper(obj0);
16327 if (arg1 == NULL) SWIG_fail;
16328 temp1 = true;
16329 }
16330 {
16331 arg2 = wxString_in_helper(obj1);
16332 if (arg2 == NULL) SWIG_fail;
16333 temp2 = true;
16334 }
16335 {
16336 arg3 = wxString_in_helper(obj2);
16337 if (arg3 == NULL) SWIG_fail;
16338 temp3 = true;
16339 }
16340 {
16341 arg4 = wxString_in_helper(obj3);
16342 if (arg4 == NULL) SWIG_fail;
16343 temp4 = true;
16344 }
16345 {
16346 PyThreadState* __tstate = wxPyBeginAllowThreads();
16347 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16348 wxPyEndAllowThreads(__tstate);
16349 if (PyErr_Occurred()) SWIG_fail;
16350 }
16351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16352 {
16353 if (temp1)
16354 delete arg1;
16355 }
16356 {
16357 if (temp2)
16358 delete arg2;
16359 }
16360 {
16361 if (temp3)
16362 delete arg3;
16363 }
16364 {
16365 if (temp4)
16366 delete arg4;
16367 }
16368 return resultobj;
16369 fail:
16370 {
16371 if (temp1)
16372 delete arg1;
16373 }
16374 {
16375 if (temp2)
16376 delete arg2;
16377 }
16378 {
16379 if (temp3)
16380 delete arg3;
16381 }
16382 {
16383 if (temp4)
16384 delete arg4;
16385 }
16386 return NULL;
16387 }
16388
16389
16390 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16391 PyObject *resultobj = 0;
16392 wxArrayString *arg1 = 0 ;
16393 wxFileTypeInfo *result = 0 ;
16394 bool temp1 = false ;
16395 PyObject * obj0 = 0 ;
16396 char * kwnames[] = {
16397 (char *) "sArray", NULL
16398 };
16399
16400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16401 {
16402 if (! PySequence_Check(obj0)) {
16403 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16404 SWIG_fail;
16405 }
16406 arg1 = new wxArrayString;
16407 temp1 = true;
16408 int i, len=PySequence_Length(obj0);
16409 for (i=0; i<len; i++) {
16410 PyObject* item = PySequence_GetItem(obj0, i);
16411 wxString* s = wxString_in_helper(item);
16412 if (PyErr_Occurred()) SWIG_fail;
16413 arg1->Add(*s);
16414 delete s;
16415 Py_DECREF(item);
16416 }
16417 }
16418 {
16419 PyThreadState* __tstate = wxPyBeginAllowThreads();
16420 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16421 wxPyEndAllowThreads(__tstate);
16422 if (PyErr_Occurred()) SWIG_fail;
16423 }
16424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16425 {
16426 if (temp1) delete arg1;
16427 }
16428 return resultobj;
16429 fail:
16430 {
16431 if (temp1) delete arg1;
16432 }
16433 return NULL;
16434 }
16435
16436
16437 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16438 PyObject *resultobj = 0;
16439 wxFileTypeInfo *result = 0 ;
16440
16441 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16442 {
16443 PyThreadState* __tstate = wxPyBeginAllowThreads();
16444 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16445 wxPyEndAllowThreads(__tstate);
16446 if (PyErr_Occurred()) SWIG_fail;
16447 }
16448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16449 return resultobj;
16450 fail:
16451 return NULL;
16452 }
16453
16454
16455 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16456 PyObject *resultobj = 0;
16457 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16458 bool result;
16459 void *argp1 = 0 ;
16460 int res1 = 0 ;
16461 PyObject *swig_obj[1] ;
16462
16463 if (!args) SWIG_fail;
16464 swig_obj[0] = args;
16465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16466 if (!SWIG_IsOK(res1)) {
16467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16468 }
16469 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16470 {
16471 PyThreadState* __tstate = wxPyBeginAllowThreads();
16472 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16473 wxPyEndAllowThreads(__tstate);
16474 if (PyErr_Occurred()) SWIG_fail;
16475 }
16476 {
16477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16478 }
16479 return resultobj;
16480 fail:
16481 return NULL;
16482 }
16483
16484
16485 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16486 PyObject *resultobj = 0;
16487 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16488 wxString *arg2 = 0 ;
16489 int arg3 = (int) 0 ;
16490 void *argp1 = 0 ;
16491 int res1 = 0 ;
16492 bool temp2 = false ;
16493 int val3 ;
16494 int ecode3 = 0 ;
16495 PyObject * obj0 = 0 ;
16496 PyObject * obj1 = 0 ;
16497 PyObject * obj2 = 0 ;
16498 char * kwnames[] = {
16499 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16500 };
16501
16502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16504 if (!SWIG_IsOK(res1)) {
16505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16506 }
16507 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16508 {
16509 arg2 = wxString_in_helper(obj1);
16510 if (arg2 == NULL) SWIG_fail;
16511 temp2 = true;
16512 }
16513 if (obj2) {
16514 ecode3 = SWIG_AsVal_int(obj2, &val3);
16515 if (!SWIG_IsOK(ecode3)) {
16516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16517 }
16518 arg3 = static_cast< int >(val3);
16519 }
16520 {
16521 PyThreadState* __tstate = wxPyBeginAllowThreads();
16522 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 resultobj = SWIG_Py_Void();
16527 {
16528 if (temp2)
16529 delete arg2;
16530 }
16531 return resultobj;
16532 fail:
16533 {
16534 if (temp2)
16535 delete arg2;
16536 }
16537 return NULL;
16538 }
16539
16540
16541 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16542 PyObject *resultobj = 0;
16543 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16544 wxString *arg2 = 0 ;
16545 void *argp1 = 0 ;
16546 int res1 = 0 ;
16547 bool temp2 = false ;
16548 PyObject * obj0 = 0 ;
16549 PyObject * obj1 = 0 ;
16550 char * kwnames[] = {
16551 (char *) "self",(char *) "shortDesc", NULL
16552 };
16553
16554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16556 if (!SWIG_IsOK(res1)) {
16557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16558 }
16559 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16560 {
16561 arg2 = wxString_in_helper(obj1);
16562 if (arg2 == NULL) SWIG_fail;
16563 temp2 = true;
16564 }
16565 {
16566 PyThreadState* __tstate = wxPyBeginAllowThreads();
16567 (arg1)->SetShortDesc((wxString const &)*arg2);
16568 wxPyEndAllowThreads(__tstate);
16569 if (PyErr_Occurred()) SWIG_fail;
16570 }
16571 resultobj = SWIG_Py_Void();
16572 {
16573 if (temp2)
16574 delete arg2;
16575 }
16576 return resultobj;
16577 fail:
16578 {
16579 if (temp2)
16580 delete arg2;
16581 }
16582 return NULL;
16583 }
16584
16585
16586 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16587 PyObject *resultobj = 0;
16588 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16589 wxString *result = 0 ;
16590 void *argp1 = 0 ;
16591 int res1 = 0 ;
16592 PyObject *swig_obj[1] ;
16593
16594 if (!args) SWIG_fail;
16595 swig_obj[0] = args;
16596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16597 if (!SWIG_IsOK(res1)) {
16598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16599 }
16600 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16601 {
16602 PyThreadState* __tstate = wxPyBeginAllowThreads();
16603 {
16604 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16605 result = (wxString *) &_result_ref;
16606 }
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 {
16611 #if wxUSE_UNICODE
16612 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16613 #else
16614 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16615 #endif
16616 }
16617 return resultobj;
16618 fail:
16619 return NULL;
16620 }
16621
16622
16623 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16624 PyObject *resultobj = 0;
16625 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16626 wxString *result = 0 ;
16627 void *argp1 = 0 ;
16628 int res1 = 0 ;
16629 PyObject *swig_obj[1] ;
16630
16631 if (!args) SWIG_fail;
16632 swig_obj[0] = args;
16633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16634 if (!SWIG_IsOK(res1)) {
16635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16636 }
16637 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16638 {
16639 PyThreadState* __tstate = wxPyBeginAllowThreads();
16640 {
16641 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16642 result = (wxString *) &_result_ref;
16643 }
16644 wxPyEndAllowThreads(__tstate);
16645 if (PyErr_Occurred()) SWIG_fail;
16646 }
16647 {
16648 #if wxUSE_UNICODE
16649 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16650 #else
16651 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16652 #endif
16653 }
16654 return resultobj;
16655 fail:
16656 return NULL;
16657 }
16658
16659
16660 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16661 PyObject *resultobj = 0;
16662 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16663 wxString *result = 0 ;
16664 void *argp1 = 0 ;
16665 int res1 = 0 ;
16666 PyObject *swig_obj[1] ;
16667
16668 if (!args) SWIG_fail;
16669 swig_obj[0] = args;
16670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16671 if (!SWIG_IsOK(res1)) {
16672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16673 }
16674 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16675 {
16676 PyThreadState* __tstate = wxPyBeginAllowThreads();
16677 {
16678 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16679 result = (wxString *) &_result_ref;
16680 }
16681 wxPyEndAllowThreads(__tstate);
16682 if (PyErr_Occurred()) SWIG_fail;
16683 }
16684 {
16685 #if wxUSE_UNICODE
16686 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16687 #else
16688 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16689 #endif
16690 }
16691 return resultobj;
16692 fail:
16693 return NULL;
16694 }
16695
16696
16697 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16698 PyObject *resultobj = 0;
16699 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16700 wxString *result = 0 ;
16701 void *argp1 = 0 ;
16702 int res1 = 0 ;
16703 PyObject *swig_obj[1] ;
16704
16705 if (!args) SWIG_fail;
16706 swig_obj[0] = args;
16707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16708 if (!SWIG_IsOK(res1)) {
16709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16710 }
16711 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16712 {
16713 PyThreadState* __tstate = wxPyBeginAllowThreads();
16714 {
16715 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16716 result = (wxString *) &_result_ref;
16717 }
16718 wxPyEndAllowThreads(__tstate);
16719 if (PyErr_Occurred()) SWIG_fail;
16720 }
16721 {
16722 #if wxUSE_UNICODE
16723 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16724 #else
16725 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16726 #endif
16727 }
16728 return resultobj;
16729 fail:
16730 return NULL;
16731 }
16732
16733
16734 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16735 PyObject *resultobj = 0;
16736 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16737 wxString *result = 0 ;
16738 void *argp1 = 0 ;
16739 int res1 = 0 ;
16740 PyObject *swig_obj[1] ;
16741
16742 if (!args) SWIG_fail;
16743 swig_obj[0] = args;
16744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16745 if (!SWIG_IsOK(res1)) {
16746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16747 }
16748 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16749 {
16750 PyThreadState* __tstate = wxPyBeginAllowThreads();
16751 {
16752 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16753 result = (wxString *) &_result_ref;
16754 }
16755 wxPyEndAllowThreads(__tstate);
16756 if (PyErr_Occurred()) SWIG_fail;
16757 }
16758 {
16759 #if wxUSE_UNICODE
16760 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16761 #else
16762 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16763 #endif
16764 }
16765 return resultobj;
16766 fail:
16767 return NULL;
16768 }
16769
16770
16771 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16772 PyObject *resultobj = 0;
16773 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16774 wxArrayString *result = 0 ;
16775 void *argp1 = 0 ;
16776 int res1 = 0 ;
16777 PyObject *swig_obj[1] ;
16778
16779 if (!args) SWIG_fail;
16780 swig_obj[0] = args;
16781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16782 if (!SWIG_IsOK(res1)) {
16783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16784 }
16785 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16786 {
16787 PyThreadState* __tstate = wxPyBeginAllowThreads();
16788 {
16789 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16790 result = (wxArrayString *) &_result_ref;
16791 }
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 {
16796 resultobj = wxArrayString2PyList_helper(*result);
16797 }
16798 return resultobj;
16799 fail:
16800 return NULL;
16801 }
16802
16803
16804 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16805 PyObject *resultobj = 0;
16806 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16807 size_t result;
16808 void *argp1 = 0 ;
16809 int res1 = 0 ;
16810 PyObject *swig_obj[1] ;
16811
16812 if (!args) SWIG_fail;
16813 swig_obj[0] = args;
16814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16815 if (!SWIG_IsOK(res1)) {
16816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16817 }
16818 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16819 {
16820 PyThreadState* __tstate = wxPyBeginAllowThreads();
16821 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16822 wxPyEndAllowThreads(__tstate);
16823 if (PyErr_Occurred()) SWIG_fail;
16824 }
16825 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16833 PyObject *resultobj = 0;
16834 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16835 wxString *result = 0 ;
16836 void *argp1 = 0 ;
16837 int res1 = 0 ;
16838 PyObject *swig_obj[1] ;
16839
16840 if (!args) SWIG_fail;
16841 swig_obj[0] = args;
16842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16843 if (!SWIG_IsOK(res1)) {
16844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16845 }
16846 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16847 {
16848 PyThreadState* __tstate = wxPyBeginAllowThreads();
16849 {
16850 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16851 result = (wxString *) &_result_ref;
16852 }
16853 wxPyEndAllowThreads(__tstate);
16854 if (PyErr_Occurred()) SWIG_fail;
16855 }
16856 {
16857 #if wxUSE_UNICODE
16858 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16859 #else
16860 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16861 #endif
16862 }
16863 return resultobj;
16864 fail:
16865 return NULL;
16866 }
16867
16868
16869 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16870 PyObject *resultobj = 0;
16871 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16872 int result;
16873 void *argp1 = 0 ;
16874 int res1 = 0 ;
16875 PyObject *swig_obj[1] ;
16876
16877 if (!args) SWIG_fail;
16878 swig_obj[0] = args;
16879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16880 if (!SWIG_IsOK(res1)) {
16881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16882 }
16883 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16884 {
16885 PyThreadState* __tstate = wxPyBeginAllowThreads();
16886 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16887 wxPyEndAllowThreads(__tstate);
16888 if (PyErr_Occurred()) SWIG_fail;
16889 }
16890 resultobj = SWIG_From_int(static_cast< int >(result));
16891 return resultobj;
16892 fail:
16893 return NULL;
16894 }
16895
16896
16897 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16898 PyObject *obj;
16899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16900 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16901 return SWIG_Py_Void();
16902 }
16903
16904 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16905 return SWIG_Python_InitShadowInstance(args);
16906 }
16907
16908 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16909 PyObject *resultobj = 0;
16910 wxFileTypeInfo *arg1 = 0 ;
16911 wxFileType *result = 0 ;
16912 void *argp1 = 0 ;
16913 int res1 = 0 ;
16914 PyObject * obj0 = 0 ;
16915 char * kwnames[] = {
16916 (char *) "ftInfo", NULL
16917 };
16918
16919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16920 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16921 if (!SWIG_IsOK(res1)) {
16922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16923 }
16924 if (!argp1) {
16925 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16926 }
16927 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16928 {
16929 PyThreadState* __tstate = wxPyBeginAllowThreads();
16930 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16942 PyObject *resultobj = 0;
16943 wxFileType *arg1 = (wxFileType *) 0 ;
16944 void *argp1 = 0 ;
16945 int res1 = 0 ;
16946 PyObject *swig_obj[1] ;
16947
16948 if (!args) SWIG_fail;
16949 swig_obj[0] = args;
16950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16951 if (!SWIG_IsOK(res1)) {
16952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16953 }
16954 arg1 = reinterpret_cast< wxFileType * >(argp1);
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 delete arg1;
16958
16959 wxPyEndAllowThreads(__tstate);
16960 if (PyErr_Occurred()) SWIG_fail;
16961 }
16962 resultobj = SWIG_Py_Void();
16963 return resultobj;
16964 fail:
16965 return NULL;
16966 }
16967
16968
16969 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16970 PyObject *resultobj = 0;
16971 wxFileType *arg1 = (wxFileType *) 0 ;
16972 PyObject *result = 0 ;
16973 void *argp1 = 0 ;
16974 int res1 = 0 ;
16975 PyObject *swig_obj[1] ;
16976
16977 if (!args) SWIG_fail;
16978 swig_obj[0] = args;
16979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16980 if (!SWIG_IsOK(res1)) {
16981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16982 }
16983 arg1 = reinterpret_cast< wxFileType * >(argp1);
16984 {
16985 PyThreadState* __tstate = wxPyBeginAllowThreads();
16986 result = (PyObject *)wxFileType_GetMimeType(arg1);
16987 wxPyEndAllowThreads(__tstate);
16988 if (PyErr_Occurred()) SWIG_fail;
16989 }
16990 resultobj = result;
16991 return resultobj;
16992 fail:
16993 return NULL;
16994 }
16995
16996
16997 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16998 PyObject *resultobj = 0;
16999 wxFileType *arg1 = (wxFileType *) 0 ;
17000 PyObject *result = 0 ;
17001 void *argp1 = 0 ;
17002 int res1 = 0 ;
17003 PyObject *swig_obj[1] ;
17004
17005 if (!args) SWIG_fail;
17006 swig_obj[0] = args;
17007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17008 if (!SWIG_IsOK(res1)) {
17009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17010 }
17011 arg1 = reinterpret_cast< wxFileType * >(argp1);
17012 {
17013 PyThreadState* __tstate = wxPyBeginAllowThreads();
17014 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 resultobj = result;
17019 return resultobj;
17020 fail:
17021 return NULL;
17022 }
17023
17024
17025 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17026 PyObject *resultobj = 0;
17027 wxFileType *arg1 = (wxFileType *) 0 ;
17028 PyObject *result = 0 ;
17029 void *argp1 = 0 ;
17030 int res1 = 0 ;
17031 PyObject *swig_obj[1] ;
17032
17033 if (!args) SWIG_fail;
17034 swig_obj[0] = args;
17035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17036 if (!SWIG_IsOK(res1)) {
17037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
17038 }
17039 arg1 = reinterpret_cast< wxFileType * >(argp1);
17040 {
17041 PyThreadState* __tstate = wxPyBeginAllowThreads();
17042 result = (PyObject *)wxFileType_GetExtensions(arg1);
17043 wxPyEndAllowThreads(__tstate);
17044 if (PyErr_Occurred()) SWIG_fail;
17045 }
17046 resultobj = result;
17047 return resultobj;
17048 fail:
17049 return NULL;
17050 }
17051
17052
17053 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17054 PyObject *resultobj = 0;
17055 wxFileType *arg1 = (wxFileType *) 0 ;
17056 wxIcon *result = 0 ;
17057 void *argp1 = 0 ;
17058 int res1 = 0 ;
17059 PyObject *swig_obj[1] ;
17060
17061 if (!args) SWIG_fail;
17062 swig_obj[0] = args;
17063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17064 if (!SWIG_IsOK(res1)) {
17065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17066 }
17067 arg1 = reinterpret_cast< wxFileType * >(argp1);
17068 {
17069 PyThreadState* __tstate = wxPyBeginAllowThreads();
17070 result = (wxIcon *)wxFileType_GetIcon(arg1);
17071 wxPyEndAllowThreads(__tstate);
17072 if (PyErr_Occurred()) SWIG_fail;
17073 }
17074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17082 PyObject *resultobj = 0;
17083 wxFileType *arg1 = (wxFileType *) 0 ;
17084 PyObject *result = 0 ;
17085 void *argp1 = 0 ;
17086 int res1 = 0 ;
17087 PyObject *swig_obj[1] ;
17088
17089 if (!args) SWIG_fail;
17090 swig_obj[0] = args;
17091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17092 if (!SWIG_IsOK(res1)) {
17093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
17094 }
17095 arg1 = reinterpret_cast< wxFileType * >(argp1);
17096 {
17097 PyThreadState* __tstate = wxPyBeginAllowThreads();
17098 result = (PyObject *)wxFileType_GetIconInfo(arg1);
17099 wxPyEndAllowThreads(__tstate);
17100 if (PyErr_Occurred()) SWIG_fail;
17101 }
17102 resultobj = result;
17103 return resultobj;
17104 fail:
17105 return NULL;
17106 }
17107
17108
17109 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17110 PyObject *resultobj = 0;
17111 wxFileType *arg1 = (wxFileType *) 0 ;
17112 PyObject *result = 0 ;
17113 void *argp1 = 0 ;
17114 int res1 = 0 ;
17115 PyObject *swig_obj[1] ;
17116
17117 if (!args) SWIG_fail;
17118 swig_obj[0] = args;
17119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17120 if (!SWIG_IsOK(res1)) {
17121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
17122 }
17123 arg1 = reinterpret_cast< wxFileType * >(argp1);
17124 {
17125 PyThreadState* __tstate = wxPyBeginAllowThreads();
17126 result = (PyObject *)wxFileType_GetDescription(arg1);
17127 wxPyEndAllowThreads(__tstate);
17128 if (PyErr_Occurred()) SWIG_fail;
17129 }
17130 resultobj = result;
17131 return resultobj;
17132 fail:
17133 return NULL;
17134 }
17135
17136
17137 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17138 PyObject *resultobj = 0;
17139 wxFileType *arg1 = (wxFileType *) 0 ;
17140 wxString *arg2 = 0 ;
17141 wxString const &arg3_defvalue = wxPyEmptyString ;
17142 wxString *arg3 = (wxString *) &arg3_defvalue ;
17143 PyObject *result = 0 ;
17144 void *argp1 = 0 ;
17145 int res1 = 0 ;
17146 bool temp2 = false ;
17147 bool temp3 = false ;
17148 PyObject * obj0 = 0 ;
17149 PyObject * obj1 = 0 ;
17150 PyObject * obj2 = 0 ;
17151 char * kwnames[] = {
17152 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17153 };
17154
17155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17157 if (!SWIG_IsOK(res1)) {
17158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17159 }
17160 arg1 = reinterpret_cast< wxFileType * >(argp1);
17161 {
17162 arg2 = wxString_in_helper(obj1);
17163 if (arg2 == NULL) SWIG_fail;
17164 temp2 = true;
17165 }
17166 if (obj2) {
17167 {
17168 arg3 = wxString_in_helper(obj2);
17169 if (arg3 == NULL) SWIG_fail;
17170 temp3 = true;
17171 }
17172 }
17173 {
17174 PyThreadState* __tstate = wxPyBeginAllowThreads();
17175 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17176 wxPyEndAllowThreads(__tstate);
17177 if (PyErr_Occurred()) SWIG_fail;
17178 }
17179 resultobj = result;
17180 {
17181 if (temp2)
17182 delete arg2;
17183 }
17184 {
17185 if (temp3)
17186 delete arg3;
17187 }
17188 return resultobj;
17189 fail:
17190 {
17191 if (temp2)
17192 delete arg2;
17193 }
17194 {
17195 if (temp3)
17196 delete arg3;
17197 }
17198 return NULL;
17199 }
17200
17201
17202 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17203 PyObject *resultobj = 0;
17204 wxFileType *arg1 = (wxFileType *) 0 ;
17205 wxString *arg2 = 0 ;
17206 wxString const &arg3_defvalue = wxPyEmptyString ;
17207 wxString *arg3 = (wxString *) &arg3_defvalue ;
17208 PyObject *result = 0 ;
17209 void *argp1 = 0 ;
17210 int res1 = 0 ;
17211 bool temp2 = false ;
17212 bool temp3 = false ;
17213 PyObject * obj0 = 0 ;
17214 PyObject * obj1 = 0 ;
17215 PyObject * obj2 = 0 ;
17216 char * kwnames[] = {
17217 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17218 };
17219
17220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17222 if (!SWIG_IsOK(res1)) {
17223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17224 }
17225 arg1 = reinterpret_cast< wxFileType * >(argp1);
17226 {
17227 arg2 = wxString_in_helper(obj1);
17228 if (arg2 == NULL) SWIG_fail;
17229 temp2 = true;
17230 }
17231 if (obj2) {
17232 {
17233 arg3 = wxString_in_helper(obj2);
17234 if (arg3 == NULL) SWIG_fail;
17235 temp3 = true;
17236 }
17237 }
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 resultobj = result;
17245 {
17246 if (temp2)
17247 delete arg2;
17248 }
17249 {
17250 if (temp3)
17251 delete arg3;
17252 }
17253 return resultobj;
17254 fail:
17255 {
17256 if (temp2)
17257 delete arg2;
17258 }
17259 {
17260 if (temp3)
17261 delete arg3;
17262 }
17263 return NULL;
17264 }
17265
17266
17267 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17268 PyObject *resultobj = 0;
17269 wxFileType *arg1 = (wxFileType *) 0 ;
17270 wxString *arg2 = 0 ;
17271 wxString const &arg3_defvalue = wxPyEmptyString ;
17272 wxString *arg3 = (wxString *) &arg3_defvalue ;
17273 PyObject *result = 0 ;
17274 void *argp1 = 0 ;
17275 int res1 = 0 ;
17276 bool temp2 = false ;
17277 bool temp3 = false ;
17278 PyObject * obj0 = 0 ;
17279 PyObject * obj1 = 0 ;
17280 PyObject * obj2 = 0 ;
17281 char * kwnames[] = {
17282 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17283 };
17284
17285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17287 if (!SWIG_IsOK(res1)) {
17288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17289 }
17290 arg1 = reinterpret_cast< wxFileType * >(argp1);
17291 {
17292 arg2 = wxString_in_helper(obj1);
17293 if (arg2 == NULL) SWIG_fail;
17294 temp2 = true;
17295 }
17296 if (obj2) {
17297 {
17298 arg3 = wxString_in_helper(obj2);
17299 if (arg3 == NULL) SWIG_fail;
17300 temp3 = true;
17301 }
17302 }
17303 {
17304 PyThreadState* __tstate = wxPyBeginAllowThreads();
17305 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17306 wxPyEndAllowThreads(__tstate);
17307 if (PyErr_Occurred()) SWIG_fail;
17308 }
17309 resultobj = result;
17310 {
17311 if (temp2)
17312 delete arg2;
17313 }
17314 {
17315 if (temp3)
17316 delete arg3;
17317 }
17318 return resultobj;
17319 fail:
17320 {
17321 if (temp2)
17322 delete arg2;
17323 }
17324 {
17325 if (temp3)
17326 delete arg3;
17327 }
17328 return NULL;
17329 }
17330
17331
17332 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17333 PyObject *resultobj = 0;
17334 wxFileType *arg1 = (wxFileType *) 0 ;
17335 wxString *arg2 = 0 ;
17336 wxString *arg3 = 0 ;
17337 bool arg4 = (bool) true ;
17338 bool result;
17339 void *argp1 = 0 ;
17340 int res1 = 0 ;
17341 bool temp2 = false ;
17342 bool temp3 = false ;
17343 bool val4 ;
17344 int ecode4 = 0 ;
17345 PyObject * obj0 = 0 ;
17346 PyObject * obj1 = 0 ;
17347 PyObject * obj2 = 0 ;
17348 PyObject * obj3 = 0 ;
17349 char * kwnames[] = {
17350 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17351 };
17352
17353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17355 if (!SWIG_IsOK(res1)) {
17356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17357 }
17358 arg1 = reinterpret_cast< wxFileType * >(argp1);
17359 {
17360 arg2 = wxString_in_helper(obj1);
17361 if (arg2 == NULL) SWIG_fail;
17362 temp2 = true;
17363 }
17364 {
17365 arg3 = wxString_in_helper(obj2);
17366 if (arg3 == NULL) SWIG_fail;
17367 temp3 = true;
17368 }
17369 if (obj3) {
17370 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17371 if (!SWIG_IsOK(ecode4)) {
17372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17373 }
17374 arg4 = static_cast< bool >(val4);
17375 }
17376 {
17377 PyThreadState* __tstate = wxPyBeginAllowThreads();
17378 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17379 wxPyEndAllowThreads(__tstate);
17380 if (PyErr_Occurred()) SWIG_fail;
17381 }
17382 {
17383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17384 }
17385 {
17386 if (temp2)
17387 delete arg2;
17388 }
17389 {
17390 if (temp3)
17391 delete arg3;
17392 }
17393 return resultobj;
17394 fail:
17395 {
17396 if (temp2)
17397 delete arg2;
17398 }
17399 {
17400 if (temp3)
17401 delete arg3;
17402 }
17403 return NULL;
17404 }
17405
17406
17407 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17408 PyObject *resultobj = 0;
17409 wxFileType *arg1 = (wxFileType *) 0 ;
17410 wxString const &arg2_defvalue = wxPyEmptyString ;
17411 wxString *arg2 = (wxString *) &arg2_defvalue ;
17412 int arg3 = (int) 0 ;
17413 bool result;
17414 void *argp1 = 0 ;
17415 int res1 = 0 ;
17416 bool temp2 = false ;
17417 int val3 ;
17418 int ecode3 = 0 ;
17419 PyObject * obj0 = 0 ;
17420 PyObject * obj1 = 0 ;
17421 PyObject * obj2 = 0 ;
17422 char * kwnames[] = {
17423 (char *) "self",(char *) "cmd",(char *) "index", NULL
17424 };
17425
17426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17428 if (!SWIG_IsOK(res1)) {
17429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17430 }
17431 arg1 = reinterpret_cast< wxFileType * >(argp1);
17432 if (obj1) {
17433 {
17434 arg2 = wxString_in_helper(obj1);
17435 if (arg2 == NULL) SWIG_fail;
17436 temp2 = true;
17437 }
17438 }
17439 if (obj2) {
17440 ecode3 = SWIG_AsVal_int(obj2, &val3);
17441 if (!SWIG_IsOK(ecode3)) {
17442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17443 }
17444 arg3 = static_cast< int >(val3);
17445 }
17446 {
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 {
17453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17454 }
17455 {
17456 if (temp2)
17457 delete arg2;
17458 }
17459 return resultobj;
17460 fail:
17461 {
17462 if (temp2)
17463 delete arg2;
17464 }
17465 return NULL;
17466 }
17467
17468
17469 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17470 PyObject *resultobj = 0;
17471 wxFileType *arg1 = (wxFileType *) 0 ;
17472 bool result;
17473 void *argp1 = 0 ;
17474 int res1 = 0 ;
17475 PyObject *swig_obj[1] ;
17476
17477 if (!args) SWIG_fail;
17478 swig_obj[0] = args;
17479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17480 if (!SWIG_IsOK(res1)) {
17481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17482 }
17483 arg1 = reinterpret_cast< wxFileType * >(argp1);
17484 {
17485 PyThreadState* __tstate = wxPyBeginAllowThreads();
17486 result = (bool)(arg1)->Unassociate();
17487 wxPyEndAllowThreads(__tstate);
17488 if (PyErr_Occurred()) SWIG_fail;
17489 }
17490 {
17491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17492 }
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj = 0;
17501 wxString *arg1 = 0 ;
17502 wxString *arg2 = 0 ;
17503 wxString const &arg3_defvalue = wxPyEmptyString ;
17504 wxString *arg3 = (wxString *) &arg3_defvalue ;
17505 wxString result;
17506 bool temp1 = false ;
17507 bool temp2 = false ;
17508 bool temp3 = false ;
17509 PyObject * obj0 = 0 ;
17510 PyObject * obj1 = 0 ;
17511 PyObject * obj2 = 0 ;
17512 char * kwnames[] = {
17513 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17514 };
17515
17516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17517 {
17518 arg1 = wxString_in_helper(obj0);
17519 if (arg1 == NULL) SWIG_fail;
17520 temp1 = true;
17521 }
17522 {
17523 arg2 = wxString_in_helper(obj1);
17524 if (arg2 == NULL) SWIG_fail;
17525 temp2 = true;
17526 }
17527 if (obj2) {
17528 {
17529 arg3 = wxString_in_helper(obj2);
17530 if (arg3 == NULL) SWIG_fail;
17531 temp3 = true;
17532 }
17533 }
17534 {
17535 PyThreadState* __tstate = wxPyBeginAllowThreads();
17536 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17537 wxPyEndAllowThreads(__tstate);
17538 if (PyErr_Occurred()) SWIG_fail;
17539 }
17540 {
17541 #if wxUSE_UNICODE
17542 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17543 #else
17544 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17545 #endif
17546 }
17547 {
17548 if (temp1)
17549 delete arg1;
17550 }
17551 {
17552 if (temp2)
17553 delete arg2;
17554 }
17555 {
17556 if (temp3)
17557 delete arg3;
17558 }
17559 return resultobj;
17560 fail:
17561 {
17562 if (temp1)
17563 delete arg1;
17564 }
17565 {
17566 if (temp2)
17567 delete arg2;
17568 }
17569 {
17570 if (temp3)
17571 delete arg3;
17572 }
17573 return NULL;
17574 }
17575
17576
17577 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17578 PyObject *obj;
17579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17580 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17581 return SWIG_Py_Void();
17582 }
17583
17584 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17585 return SWIG_Python_InitShadowInstance(args);
17586 }
17587
17588 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17589 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17590 return 1;
17591 }
17592
17593
17594 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17595 PyObject *pyobj = 0;
17596
17597 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17598 return pyobj;
17599 }
17600
17601
17602 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17603 PyObject *resultobj = 0;
17604 wxString *arg1 = 0 ;
17605 wxString *arg2 = 0 ;
17606 bool result;
17607 bool temp1 = false ;
17608 bool temp2 = false ;
17609 PyObject * obj0 = 0 ;
17610 PyObject * obj1 = 0 ;
17611 char * kwnames[] = {
17612 (char *) "mimeType",(char *) "wildcard", NULL
17613 };
17614
17615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17616 {
17617 arg1 = wxString_in_helper(obj0);
17618 if (arg1 == NULL) SWIG_fail;
17619 temp1 = true;
17620 }
17621 {
17622 arg2 = wxString_in_helper(obj1);
17623 if (arg2 == NULL) SWIG_fail;
17624 temp2 = true;
17625 }
17626 {
17627 PyThreadState* __tstate = wxPyBeginAllowThreads();
17628 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17629 wxPyEndAllowThreads(__tstate);
17630 if (PyErr_Occurred()) SWIG_fail;
17631 }
17632 {
17633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17634 }
17635 {
17636 if (temp1)
17637 delete arg1;
17638 }
17639 {
17640 if (temp2)
17641 delete arg2;
17642 }
17643 return resultobj;
17644 fail:
17645 {
17646 if (temp1)
17647 delete arg1;
17648 }
17649 {
17650 if (temp2)
17651 delete arg2;
17652 }
17653 return NULL;
17654 }
17655
17656
17657 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17658 PyObject *resultobj = 0;
17659 wxMimeTypesManager *result = 0 ;
17660
17661 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17662 {
17663 PyThreadState* __tstate = wxPyBeginAllowThreads();
17664 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17665 wxPyEndAllowThreads(__tstate);
17666 if (PyErr_Occurred()) SWIG_fail;
17667 }
17668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17676 PyObject *resultobj = 0;
17677 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17678 int arg2 = (int) wxMAILCAP_ALL ;
17679 wxString const &arg3_defvalue = wxPyEmptyString ;
17680 wxString *arg3 = (wxString *) &arg3_defvalue ;
17681 void *argp1 = 0 ;
17682 int res1 = 0 ;
17683 int val2 ;
17684 int ecode2 = 0 ;
17685 bool temp3 = false ;
17686 PyObject * obj0 = 0 ;
17687 PyObject * obj1 = 0 ;
17688 PyObject * obj2 = 0 ;
17689 char * kwnames[] = {
17690 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17691 };
17692
17693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17695 if (!SWIG_IsOK(res1)) {
17696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17697 }
17698 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17699 if (obj1) {
17700 ecode2 = SWIG_AsVal_int(obj1, &val2);
17701 if (!SWIG_IsOK(ecode2)) {
17702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17703 }
17704 arg2 = static_cast< int >(val2);
17705 }
17706 if (obj2) {
17707 {
17708 arg3 = wxString_in_helper(obj2);
17709 if (arg3 == NULL) SWIG_fail;
17710 temp3 = true;
17711 }
17712 }
17713 {
17714 PyThreadState* __tstate = wxPyBeginAllowThreads();
17715 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17716 wxPyEndAllowThreads(__tstate);
17717 if (PyErr_Occurred()) SWIG_fail;
17718 }
17719 resultobj = SWIG_Py_Void();
17720 {
17721 if (temp3)
17722 delete arg3;
17723 }
17724 return resultobj;
17725 fail:
17726 {
17727 if (temp3)
17728 delete arg3;
17729 }
17730 return NULL;
17731 }
17732
17733
17734 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17735 PyObject *resultobj = 0;
17736 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17737 void *argp1 = 0 ;
17738 int res1 = 0 ;
17739 PyObject *swig_obj[1] ;
17740
17741 if (!args) SWIG_fail;
17742 swig_obj[0] = args;
17743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17744 if (!SWIG_IsOK(res1)) {
17745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17746 }
17747 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17748 {
17749 PyThreadState* __tstate = wxPyBeginAllowThreads();
17750 (arg1)->ClearData();
17751 wxPyEndAllowThreads(__tstate);
17752 if (PyErr_Occurred()) SWIG_fail;
17753 }
17754 resultobj = SWIG_Py_Void();
17755 return resultobj;
17756 fail:
17757 return NULL;
17758 }
17759
17760
17761 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17762 PyObject *resultobj = 0;
17763 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17764 wxString *arg2 = 0 ;
17765 wxFileType *result = 0 ;
17766 void *argp1 = 0 ;
17767 int res1 = 0 ;
17768 bool temp2 = false ;
17769 PyObject * obj0 = 0 ;
17770 PyObject * obj1 = 0 ;
17771 char * kwnames[] = {
17772 (char *) "self",(char *) "ext", NULL
17773 };
17774
17775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17777 if (!SWIG_IsOK(res1)) {
17778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17779 }
17780 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17781 {
17782 arg2 = wxString_in_helper(obj1);
17783 if (arg2 == NULL) SWIG_fail;
17784 temp2 = true;
17785 }
17786 {
17787 PyThreadState* __tstate = wxPyBeginAllowThreads();
17788 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17793 {
17794 if (temp2)
17795 delete arg2;
17796 }
17797 return resultobj;
17798 fail:
17799 {
17800 if (temp2)
17801 delete arg2;
17802 }
17803 return NULL;
17804 }
17805
17806
17807 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17808 PyObject *resultobj = 0;
17809 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17810 wxString *arg2 = 0 ;
17811 wxFileType *result = 0 ;
17812 void *argp1 = 0 ;
17813 int res1 = 0 ;
17814 bool temp2 = false ;
17815 PyObject * obj0 = 0 ;
17816 PyObject * obj1 = 0 ;
17817 char * kwnames[] = {
17818 (char *) "self",(char *) "mimeType", NULL
17819 };
17820
17821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17823 if (!SWIG_IsOK(res1)) {
17824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17825 }
17826 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17827 {
17828 arg2 = wxString_in_helper(obj1);
17829 if (arg2 == NULL) SWIG_fail;
17830 temp2 = true;
17831 }
17832 {
17833 PyThreadState* __tstate = wxPyBeginAllowThreads();
17834 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17835 wxPyEndAllowThreads(__tstate);
17836 if (PyErr_Occurred()) SWIG_fail;
17837 }
17838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17839 {
17840 if (temp2)
17841 delete arg2;
17842 }
17843 return resultobj;
17844 fail:
17845 {
17846 if (temp2)
17847 delete arg2;
17848 }
17849 return NULL;
17850 }
17851
17852
17853 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17854 PyObject *resultobj = 0;
17855 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17856 wxString *arg2 = 0 ;
17857 bool arg3 = (bool) false ;
17858 bool result;
17859 void *argp1 = 0 ;
17860 int res1 = 0 ;
17861 bool temp2 = false ;
17862 bool val3 ;
17863 int ecode3 = 0 ;
17864 PyObject * obj0 = 0 ;
17865 PyObject * obj1 = 0 ;
17866 PyObject * obj2 = 0 ;
17867 char * kwnames[] = {
17868 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17869 };
17870
17871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17873 if (!SWIG_IsOK(res1)) {
17874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17875 }
17876 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17877 {
17878 arg2 = wxString_in_helper(obj1);
17879 if (arg2 == NULL) SWIG_fail;
17880 temp2 = true;
17881 }
17882 if (obj2) {
17883 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17884 if (!SWIG_IsOK(ecode3)) {
17885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17886 }
17887 arg3 = static_cast< bool >(val3);
17888 }
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 {
17896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17897 }
17898 {
17899 if (temp2)
17900 delete arg2;
17901 }
17902 return resultobj;
17903 fail:
17904 {
17905 if (temp2)
17906 delete arg2;
17907 }
17908 return NULL;
17909 }
17910
17911
17912 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17913 PyObject *resultobj = 0;
17914 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17915 wxString *arg2 = 0 ;
17916 bool result;
17917 void *argp1 = 0 ;
17918 int res1 = 0 ;
17919 bool temp2 = false ;
17920 PyObject * obj0 = 0 ;
17921 PyObject * obj1 = 0 ;
17922 char * kwnames[] = {
17923 (char *) "self",(char *) "filename", NULL
17924 };
17925
17926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17928 if (!SWIG_IsOK(res1)) {
17929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17930 }
17931 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17932 {
17933 arg2 = wxString_in_helper(obj1);
17934 if (arg2 == NULL) SWIG_fail;
17935 temp2 = true;
17936 }
17937 {
17938 PyThreadState* __tstate = wxPyBeginAllowThreads();
17939 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17940 wxPyEndAllowThreads(__tstate);
17941 if (PyErr_Occurred()) SWIG_fail;
17942 }
17943 {
17944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17945 }
17946 {
17947 if (temp2)
17948 delete arg2;
17949 }
17950 return resultobj;
17951 fail:
17952 {
17953 if (temp2)
17954 delete arg2;
17955 }
17956 return NULL;
17957 }
17958
17959
17960 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17961 PyObject *resultobj = 0;
17962 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17963 PyObject *result = 0 ;
17964 void *argp1 = 0 ;
17965 int res1 = 0 ;
17966 PyObject *swig_obj[1] ;
17967
17968 if (!args) SWIG_fail;
17969 swig_obj[0] = args;
17970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17971 if (!SWIG_IsOK(res1)) {
17972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17973 }
17974 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17975 {
17976 PyThreadState* __tstate = wxPyBeginAllowThreads();
17977 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17978 wxPyEndAllowThreads(__tstate);
17979 if (PyErr_Occurred()) SWIG_fail;
17980 }
17981 resultobj = result;
17982 return resultobj;
17983 fail:
17984 return NULL;
17985 }
17986
17987
17988 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17989 PyObject *resultobj = 0;
17990 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17991 wxFileTypeInfo *arg2 = 0 ;
17992 void *argp1 = 0 ;
17993 int res1 = 0 ;
17994 void *argp2 = 0 ;
17995 int res2 = 0 ;
17996 PyObject * obj0 = 0 ;
17997 PyObject * obj1 = 0 ;
17998 char * kwnames[] = {
17999 (char *) "self",(char *) "ft", NULL
18000 };
18001
18002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18004 if (!SWIG_IsOK(res1)) {
18005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18006 }
18007 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18008 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18009 if (!SWIG_IsOK(res2)) {
18010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18011 }
18012 if (!argp2) {
18013 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18014 }
18015 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18019 wxPyEndAllowThreads(__tstate);
18020 if (PyErr_Occurred()) SWIG_fail;
18021 }
18022 resultobj = SWIG_Py_Void();
18023 return resultobj;
18024 fail:
18025 return NULL;
18026 }
18027
18028
18029 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18030 PyObject *resultobj = 0;
18031 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18032 wxFileTypeInfo *arg2 = 0 ;
18033 wxFileType *result = 0 ;
18034 void *argp1 = 0 ;
18035 int res1 = 0 ;
18036 void *argp2 = 0 ;
18037 int res2 = 0 ;
18038 PyObject * obj0 = 0 ;
18039 PyObject * obj1 = 0 ;
18040 char * kwnames[] = {
18041 (char *) "self",(char *) "ftInfo", NULL
18042 };
18043
18044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
18045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18046 if (!SWIG_IsOK(res1)) {
18047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18048 }
18049 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18050 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18051 if (!SWIG_IsOK(res2)) {
18052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18053 }
18054 if (!argp2) {
18055 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18056 }
18057 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18058 {
18059 PyThreadState* __tstate = wxPyBeginAllowThreads();
18060 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
18061 wxPyEndAllowThreads(__tstate);
18062 if (PyErr_Occurred()) SWIG_fail;
18063 }
18064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18065 return resultobj;
18066 fail:
18067 return NULL;
18068 }
18069
18070
18071 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18072 PyObject *resultobj = 0;
18073 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18074 wxFileType *arg2 = (wxFileType *) 0 ;
18075 bool result;
18076 void *argp1 = 0 ;
18077 int res1 = 0 ;
18078 void *argp2 = 0 ;
18079 int res2 = 0 ;
18080 PyObject * obj0 = 0 ;
18081 PyObject * obj1 = 0 ;
18082 char * kwnames[] = {
18083 (char *) "self",(char *) "ft", NULL
18084 };
18085
18086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
18087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18088 if (!SWIG_IsOK(res1)) {
18089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18090 }
18091 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18092 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
18093 if (!SWIG_IsOK(res2)) {
18094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
18095 }
18096 arg2 = reinterpret_cast< wxFileType * >(argp2);
18097 {
18098 PyThreadState* __tstate = wxPyBeginAllowThreads();
18099 result = (bool)(arg1)->Unassociate(arg2);
18100 wxPyEndAllowThreads(__tstate);
18101 if (PyErr_Occurred()) SWIG_fail;
18102 }
18103 {
18104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18105 }
18106 return resultobj;
18107 fail:
18108 return NULL;
18109 }
18110
18111
18112 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18113 PyObject *resultobj = 0;
18114 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18115 void *argp1 = 0 ;
18116 int res1 = 0 ;
18117 PyObject *swig_obj[1] ;
18118
18119 if (!args) SWIG_fail;
18120 swig_obj[0] = args;
18121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
18122 if (!SWIG_IsOK(res1)) {
18123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18124 }
18125 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18126 {
18127 PyThreadState* __tstate = wxPyBeginAllowThreads();
18128 delete arg1;
18129
18130 wxPyEndAllowThreads(__tstate);
18131 if (PyErr_Occurred()) SWIG_fail;
18132 }
18133 resultobj = SWIG_Py_Void();
18134 return resultobj;
18135 fail:
18136 return NULL;
18137 }
18138
18139
18140 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18141 PyObject *obj;
18142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18143 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18144 return SWIG_Py_Void();
18145 }
18146
18147 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18148 return SWIG_Python_InitShadowInstance(args);
18149 }
18150
18151 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18152 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18153 return 1;
18154 }
18155
18156
18157 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18158 PyObject *pyobj = 0;
18159
18160 {
18161 #if wxUSE_UNICODE
18162 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18163 #else
18164 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18165 #endif
18166 }
18167 return pyobj;
18168 }
18169
18170
18171 SWIGINTERN int ART_MENU_set(PyObject *) {
18172 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18173 return 1;
18174 }
18175
18176
18177 SWIGINTERN PyObject *ART_MENU_get(void) {
18178 PyObject *pyobj = 0;
18179
18180 {
18181 #if wxUSE_UNICODE
18182 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18183 #else
18184 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18185 #endif
18186 }
18187 return pyobj;
18188 }
18189
18190
18191 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18192 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18193 return 1;
18194 }
18195
18196
18197 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18198 PyObject *pyobj = 0;
18199
18200 {
18201 #if wxUSE_UNICODE
18202 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18203 #else
18204 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18205 #endif
18206 }
18207 return pyobj;
18208 }
18209
18210
18211 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18212 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18213 return 1;
18214 }
18215
18216
18217 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18218 PyObject *pyobj = 0;
18219
18220 {
18221 #if wxUSE_UNICODE
18222 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18223 #else
18224 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18225 #endif
18226 }
18227 return pyobj;
18228 }
18229
18230
18231 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18232 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18233 return 1;
18234 }
18235
18236
18237 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18238 PyObject *pyobj = 0;
18239
18240 {
18241 #if wxUSE_UNICODE
18242 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18243 #else
18244 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18245 #endif
18246 }
18247 return pyobj;
18248 }
18249
18250
18251 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18252 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18253 return 1;
18254 }
18255
18256
18257 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18258 PyObject *pyobj = 0;
18259
18260 {
18261 #if wxUSE_UNICODE
18262 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18263 #else
18264 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18265 #endif
18266 }
18267 return pyobj;
18268 }
18269
18270
18271 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18272 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18273 return 1;
18274 }
18275
18276
18277 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18278 PyObject *pyobj = 0;
18279
18280 {
18281 #if wxUSE_UNICODE
18282 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18283 #else
18284 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18285 #endif
18286 }
18287 return pyobj;
18288 }
18289
18290
18291 SWIGINTERN int ART_OTHER_set(PyObject *) {
18292 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18293 return 1;
18294 }
18295
18296
18297 SWIGINTERN PyObject *ART_OTHER_get(void) {
18298 PyObject *pyobj = 0;
18299
18300 {
18301 #if wxUSE_UNICODE
18302 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18303 #else
18304 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18305 #endif
18306 }
18307 return pyobj;
18308 }
18309
18310
18311 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18312 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18313 return 1;
18314 }
18315
18316
18317 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18318 PyObject *pyobj = 0;
18319
18320 {
18321 #if wxUSE_UNICODE
18322 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18323 #else
18324 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18325 #endif
18326 }
18327 return pyobj;
18328 }
18329
18330
18331 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18332 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18333 return 1;
18334 }
18335
18336
18337 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18338 PyObject *pyobj = 0;
18339
18340 {
18341 #if wxUSE_UNICODE
18342 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18343 #else
18344 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18345 #endif
18346 }
18347 return pyobj;
18348 }
18349
18350
18351 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18352 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18353 return 1;
18354 }
18355
18356
18357 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18358 PyObject *pyobj = 0;
18359
18360 {
18361 #if wxUSE_UNICODE
18362 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18363 #else
18364 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18365 #endif
18366 }
18367 return pyobj;
18368 }
18369
18370
18371 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18372 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18373 return 1;
18374 }
18375
18376
18377 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18378 PyObject *pyobj = 0;
18379
18380 {
18381 #if wxUSE_UNICODE
18382 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18383 #else
18384 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18385 #endif
18386 }
18387 return pyobj;
18388 }
18389
18390
18391 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18392 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18393 return 1;
18394 }
18395
18396
18397 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18398 PyObject *pyobj = 0;
18399
18400 {
18401 #if wxUSE_UNICODE
18402 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18403 #else
18404 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18405 #endif
18406 }
18407 return pyobj;
18408 }
18409
18410
18411 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18412 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18413 return 1;
18414 }
18415
18416
18417 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18418 PyObject *pyobj = 0;
18419
18420 {
18421 #if wxUSE_UNICODE
18422 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18423 #else
18424 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18425 #endif
18426 }
18427 return pyobj;
18428 }
18429
18430
18431 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18432 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18433 return 1;
18434 }
18435
18436
18437 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18438 PyObject *pyobj = 0;
18439
18440 {
18441 #if wxUSE_UNICODE
18442 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18443 #else
18444 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18445 #endif
18446 }
18447 return pyobj;
18448 }
18449
18450
18451 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18452 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18453 return 1;
18454 }
18455
18456
18457 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18458 PyObject *pyobj = 0;
18459
18460 {
18461 #if wxUSE_UNICODE
18462 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18463 #else
18464 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18465 #endif
18466 }
18467 return pyobj;
18468 }
18469
18470
18471 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18472 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18473 return 1;
18474 }
18475
18476
18477 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18478 PyObject *pyobj = 0;
18479
18480 {
18481 #if wxUSE_UNICODE
18482 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18483 #else
18484 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18485 #endif
18486 }
18487 return pyobj;
18488 }
18489
18490
18491 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18492 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18493 return 1;
18494 }
18495
18496
18497 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18498 PyObject *pyobj = 0;
18499
18500 {
18501 #if wxUSE_UNICODE
18502 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18503 #else
18504 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18505 #endif
18506 }
18507 return pyobj;
18508 }
18509
18510
18511 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18512 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18513 return 1;
18514 }
18515
18516
18517 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18518 PyObject *pyobj = 0;
18519
18520 {
18521 #if wxUSE_UNICODE
18522 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18523 #else
18524 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18525 #endif
18526 }
18527 return pyobj;
18528 }
18529
18530
18531 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18532 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18533 return 1;
18534 }
18535
18536
18537 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18538 PyObject *pyobj = 0;
18539
18540 {
18541 #if wxUSE_UNICODE
18542 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18543 #else
18544 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18545 #endif
18546 }
18547 return pyobj;
18548 }
18549
18550
18551 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18552 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18553 return 1;
18554 }
18555
18556
18557 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18558 PyObject *pyobj = 0;
18559
18560 {
18561 #if wxUSE_UNICODE
18562 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18563 #else
18564 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18565 #endif
18566 }
18567 return pyobj;
18568 }
18569
18570
18571 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18572 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18573 return 1;
18574 }
18575
18576
18577 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18578 PyObject *pyobj = 0;
18579
18580 {
18581 #if wxUSE_UNICODE
18582 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18583 #else
18584 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18585 #endif
18586 }
18587 return pyobj;
18588 }
18589
18590
18591 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18592 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18593 return 1;
18594 }
18595
18596
18597 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18598 PyObject *pyobj = 0;
18599
18600 {
18601 #if wxUSE_UNICODE
18602 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18603 #else
18604 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18605 #endif
18606 }
18607 return pyobj;
18608 }
18609
18610
18611 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18612 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18613 return 1;
18614 }
18615
18616
18617 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18618 PyObject *pyobj = 0;
18619
18620 {
18621 #if wxUSE_UNICODE
18622 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18623 #else
18624 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18625 #endif
18626 }
18627 return pyobj;
18628 }
18629
18630
18631 SWIGINTERN int ART_PRINT_set(PyObject *) {
18632 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18633 return 1;
18634 }
18635
18636
18637 SWIGINTERN PyObject *ART_PRINT_get(void) {
18638 PyObject *pyobj = 0;
18639
18640 {
18641 #if wxUSE_UNICODE
18642 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18643 #else
18644 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18645 #endif
18646 }
18647 return pyobj;
18648 }
18649
18650
18651 SWIGINTERN int ART_HELP_set(PyObject *) {
18652 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18653 return 1;
18654 }
18655
18656
18657 SWIGINTERN PyObject *ART_HELP_get(void) {
18658 PyObject *pyobj = 0;
18659
18660 {
18661 #if wxUSE_UNICODE
18662 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18663 #else
18664 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18665 #endif
18666 }
18667 return pyobj;
18668 }
18669
18670
18671 SWIGINTERN int ART_TIP_set(PyObject *) {
18672 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18673 return 1;
18674 }
18675
18676
18677 SWIGINTERN PyObject *ART_TIP_get(void) {
18678 PyObject *pyobj = 0;
18679
18680 {
18681 #if wxUSE_UNICODE
18682 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18683 #else
18684 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18685 #endif
18686 }
18687 return pyobj;
18688 }
18689
18690
18691 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18692 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18693 return 1;
18694 }
18695
18696
18697 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18698 PyObject *pyobj = 0;
18699
18700 {
18701 #if wxUSE_UNICODE
18702 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18703 #else
18704 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18705 #endif
18706 }
18707 return pyobj;
18708 }
18709
18710
18711 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18712 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18713 return 1;
18714 }
18715
18716
18717 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18718 PyObject *pyobj = 0;
18719
18720 {
18721 #if wxUSE_UNICODE
18722 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18723 #else
18724 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18725 #endif
18726 }
18727 return pyobj;
18728 }
18729
18730
18731 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18732 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18733 return 1;
18734 }
18735
18736
18737 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18738 PyObject *pyobj = 0;
18739
18740 {
18741 #if wxUSE_UNICODE
18742 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18743 #else
18744 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18745 #endif
18746 }
18747 return pyobj;
18748 }
18749
18750
18751 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18752 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18753 return 1;
18754 }
18755
18756
18757 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18758 PyObject *pyobj = 0;
18759
18760 {
18761 #if wxUSE_UNICODE
18762 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18763 #else
18764 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18765 #endif
18766 }
18767 return pyobj;
18768 }
18769
18770
18771 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18772 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18773 return 1;
18774 }
18775
18776
18777 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18778 PyObject *pyobj = 0;
18779
18780 {
18781 #if wxUSE_UNICODE
18782 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18783 #else
18784 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18785 #endif
18786 }
18787 return pyobj;
18788 }
18789
18790
18791 SWIGINTERN int ART_CDROM_set(PyObject *) {
18792 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18793 return 1;
18794 }
18795
18796
18797 SWIGINTERN PyObject *ART_CDROM_get(void) {
18798 PyObject *pyobj = 0;
18799
18800 {
18801 #if wxUSE_UNICODE
18802 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18803 #else
18804 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18805 #endif
18806 }
18807 return pyobj;
18808 }
18809
18810
18811 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18812 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18813 return 1;
18814 }
18815
18816
18817 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18818 PyObject *pyobj = 0;
18819
18820 {
18821 #if wxUSE_UNICODE
18822 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18823 #else
18824 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18825 #endif
18826 }
18827 return pyobj;
18828 }
18829
18830
18831 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18832 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18833 return 1;
18834 }
18835
18836
18837 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18838 PyObject *pyobj = 0;
18839
18840 {
18841 #if wxUSE_UNICODE
18842 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18843 #else
18844 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18845 #endif
18846 }
18847 return pyobj;
18848 }
18849
18850
18851 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18852 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18853 return 1;
18854 }
18855
18856
18857 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18858 PyObject *pyobj = 0;
18859
18860 {
18861 #if wxUSE_UNICODE
18862 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18863 #else
18864 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18865 #endif
18866 }
18867 return pyobj;
18868 }
18869
18870
18871 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18872 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18873 return 1;
18874 }
18875
18876
18877 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18878 PyObject *pyobj = 0;
18879
18880 {
18881 #if wxUSE_UNICODE
18882 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18883 #else
18884 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18885 #endif
18886 }
18887 return pyobj;
18888 }
18889
18890
18891 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18892 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18893 return 1;
18894 }
18895
18896
18897 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18898 PyObject *pyobj = 0;
18899
18900 {
18901 #if wxUSE_UNICODE
18902 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18903 #else
18904 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18905 #endif
18906 }
18907 return pyobj;
18908 }
18909
18910
18911 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18912 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18913 return 1;
18914 }
18915
18916
18917 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18918 PyObject *pyobj = 0;
18919
18920 {
18921 #if wxUSE_UNICODE
18922 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18923 #else
18924 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18925 #endif
18926 }
18927 return pyobj;
18928 }
18929
18930
18931 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18932 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18933 return 1;
18934 }
18935
18936
18937 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18938 PyObject *pyobj = 0;
18939
18940 {
18941 #if wxUSE_UNICODE
18942 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18943 #else
18944 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18945 #endif
18946 }
18947 return pyobj;
18948 }
18949
18950
18951 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18952 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18953 return 1;
18954 }
18955
18956
18957 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18958 PyObject *pyobj = 0;
18959
18960 {
18961 #if wxUSE_UNICODE
18962 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18963 #else
18964 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18965 #endif
18966 }
18967 return pyobj;
18968 }
18969
18970
18971 SWIGINTERN int ART_ERROR_set(PyObject *) {
18972 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18973 return 1;
18974 }
18975
18976
18977 SWIGINTERN PyObject *ART_ERROR_get(void) {
18978 PyObject *pyobj = 0;
18979
18980 {
18981 #if wxUSE_UNICODE
18982 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18983 #else
18984 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18985 #endif
18986 }
18987 return pyobj;
18988 }
18989
18990
18991 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18992 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18993 return 1;
18994 }
18995
18996
18997 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18998 PyObject *pyobj = 0;
18999
19000 {
19001 #if wxUSE_UNICODE
19002 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19003 #else
19004 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19005 #endif
19006 }
19007 return pyobj;
19008 }
19009
19010
19011 SWIGINTERN int ART_WARNING_set(PyObject *) {
19012 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19013 return 1;
19014 }
19015
19016
19017 SWIGINTERN PyObject *ART_WARNING_get(void) {
19018 PyObject *pyobj = 0;
19019
19020 {
19021 #if wxUSE_UNICODE
19022 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19023 #else
19024 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19025 #endif
19026 }
19027 return pyobj;
19028 }
19029
19030
19031 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
19032 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
19033 return 1;
19034 }
19035
19036
19037 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
19038 PyObject *pyobj = 0;
19039
19040 {
19041 #if wxUSE_UNICODE
19042 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19043 #else
19044 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19045 #endif
19046 }
19047 return pyobj;
19048 }
19049
19050
19051 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
19052 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
19053 return 1;
19054 }
19055
19056
19057 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
19058 PyObject *pyobj = 0;
19059
19060 {
19061 #if wxUSE_UNICODE
19062 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19063 #else
19064 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19065 #endif
19066 }
19067 return pyobj;
19068 }
19069
19070
19071 SWIGINTERN int ART_COPY_set(PyObject *) {
19072 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
19073 return 1;
19074 }
19075
19076
19077 SWIGINTERN PyObject *ART_COPY_get(void) {
19078 PyObject *pyobj = 0;
19079
19080 {
19081 #if wxUSE_UNICODE
19082 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19083 #else
19084 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19085 #endif
19086 }
19087 return pyobj;
19088 }
19089
19090
19091 SWIGINTERN int ART_CUT_set(PyObject *) {
19092 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
19093 return 1;
19094 }
19095
19096
19097 SWIGINTERN PyObject *ART_CUT_get(void) {
19098 PyObject *pyobj = 0;
19099
19100 {
19101 #if wxUSE_UNICODE
19102 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19103 #else
19104 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19105 #endif
19106 }
19107 return pyobj;
19108 }
19109
19110
19111 SWIGINTERN int ART_PASTE_set(PyObject *) {
19112 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
19113 return 1;
19114 }
19115
19116
19117 SWIGINTERN PyObject *ART_PASTE_get(void) {
19118 PyObject *pyobj = 0;
19119
19120 {
19121 #if wxUSE_UNICODE
19122 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19123 #else
19124 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19125 #endif
19126 }
19127 return pyobj;
19128 }
19129
19130
19131 SWIGINTERN int ART_DELETE_set(PyObject *) {
19132 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19133 return 1;
19134 }
19135
19136
19137 SWIGINTERN PyObject *ART_DELETE_get(void) {
19138 PyObject *pyobj = 0;
19139
19140 {
19141 #if wxUSE_UNICODE
19142 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19143 #else
19144 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19145 #endif
19146 }
19147 return pyobj;
19148 }
19149
19150
19151 SWIGINTERN int ART_NEW_set(PyObject *) {
19152 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19153 return 1;
19154 }
19155
19156
19157 SWIGINTERN PyObject *ART_NEW_get(void) {
19158 PyObject *pyobj = 0;
19159
19160 {
19161 #if wxUSE_UNICODE
19162 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19163 #else
19164 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19165 #endif
19166 }
19167 return pyobj;
19168 }
19169
19170
19171 SWIGINTERN int ART_UNDO_set(PyObject *) {
19172 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19173 return 1;
19174 }
19175
19176
19177 SWIGINTERN PyObject *ART_UNDO_get(void) {
19178 PyObject *pyobj = 0;
19179
19180 {
19181 #if wxUSE_UNICODE
19182 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19183 #else
19184 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19185 #endif
19186 }
19187 return pyobj;
19188 }
19189
19190
19191 SWIGINTERN int ART_REDO_set(PyObject *) {
19192 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19193 return 1;
19194 }
19195
19196
19197 SWIGINTERN PyObject *ART_REDO_get(void) {
19198 PyObject *pyobj = 0;
19199
19200 {
19201 #if wxUSE_UNICODE
19202 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19203 #else
19204 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19205 #endif
19206 }
19207 return pyobj;
19208 }
19209
19210
19211 SWIGINTERN int ART_QUIT_set(PyObject *) {
19212 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19213 return 1;
19214 }
19215
19216
19217 SWIGINTERN PyObject *ART_QUIT_get(void) {
19218 PyObject *pyobj = 0;
19219
19220 {
19221 #if wxUSE_UNICODE
19222 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19223 #else
19224 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19225 #endif
19226 }
19227 return pyobj;
19228 }
19229
19230
19231 SWIGINTERN int ART_FIND_set(PyObject *) {
19232 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19233 return 1;
19234 }
19235
19236
19237 SWIGINTERN PyObject *ART_FIND_get(void) {
19238 PyObject *pyobj = 0;
19239
19240 {
19241 #if wxUSE_UNICODE
19242 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19243 #else
19244 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19245 #endif
19246 }
19247 return pyobj;
19248 }
19249
19250
19251 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19252 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19253 return 1;
19254 }
19255
19256
19257 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19258 PyObject *pyobj = 0;
19259
19260 {
19261 #if wxUSE_UNICODE
19262 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19263 #else
19264 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19265 #endif
19266 }
19267 return pyobj;
19268 }
19269
19270
19271 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19272 PyObject *resultobj = 0;
19273 wxPyArtProvider *result = 0 ;
19274
19275 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19276 {
19277 if (!wxPyCheckForApp()) SWIG_fail;
19278 PyThreadState* __tstate = wxPyBeginAllowThreads();
19279 result = (wxPyArtProvider *)new wxPyArtProvider();
19280 wxPyEndAllowThreads(__tstate);
19281 if (PyErr_Occurred()) SWIG_fail;
19282 }
19283 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19291 PyObject *resultobj = 0;
19292 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19293 void *argp1 = 0 ;
19294 int res1 = 0 ;
19295 PyObject *swig_obj[1] ;
19296
19297 if (!args) SWIG_fail;
19298 swig_obj[0] = args;
19299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19300 if (!SWIG_IsOK(res1)) {
19301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19302 }
19303 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19304 {
19305 PyThreadState* __tstate = wxPyBeginAllowThreads();
19306 delete arg1;
19307
19308 wxPyEndAllowThreads(__tstate);
19309 if (PyErr_Occurred()) SWIG_fail;
19310 }
19311 resultobj = SWIG_Py_Void();
19312 return resultobj;
19313 fail:
19314 return NULL;
19315 }
19316
19317
19318 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19319 PyObject *resultobj = 0;
19320 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19321 PyObject *arg2 = (PyObject *) 0 ;
19322 PyObject *arg3 = (PyObject *) 0 ;
19323 void *argp1 = 0 ;
19324 int res1 = 0 ;
19325 PyObject * obj0 = 0 ;
19326 PyObject * obj1 = 0 ;
19327 PyObject * obj2 = 0 ;
19328 char * kwnames[] = {
19329 (char *) "self",(char *) "self",(char *) "_class", NULL
19330 };
19331
19332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19334 if (!SWIG_IsOK(res1)) {
19335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19336 }
19337 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19338 arg2 = obj1;
19339 arg3 = obj2;
19340 {
19341 PyThreadState* __tstate = wxPyBeginAllowThreads();
19342 (arg1)->_setCallbackInfo(arg2,arg3);
19343 wxPyEndAllowThreads(__tstate);
19344 if (PyErr_Occurred()) SWIG_fail;
19345 }
19346 resultobj = SWIG_Py_Void();
19347 return resultobj;
19348 fail:
19349 return NULL;
19350 }
19351
19352
19353 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19354 PyObject *resultobj = 0;
19355 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19356 int res1 = 0 ;
19357 PyObject * obj0 = 0 ;
19358 char * kwnames[] = {
19359 (char *) "provider", NULL
19360 };
19361
19362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19363 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19364 if (!SWIG_IsOK(res1)) {
19365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19366 }
19367 {
19368 PyThreadState* __tstate = wxPyBeginAllowThreads();
19369 wxPyArtProvider::PushProvider(arg1);
19370 wxPyEndAllowThreads(__tstate);
19371 if (PyErr_Occurred()) SWIG_fail;
19372 }
19373 resultobj = SWIG_Py_Void();
19374 return resultobj;
19375 fail:
19376 return NULL;
19377 }
19378
19379
19380 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19381 PyObject *resultobj = 0;
19382 bool result;
19383
19384 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 result = (bool)wxPyArtProvider::PopProvider();
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 {
19392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19393 }
19394 return resultobj;
19395 fail:
19396 return NULL;
19397 }
19398
19399
19400 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19401 PyObject *resultobj = 0;
19402 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19403 bool result;
19404 void *argp1 = 0 ;
19405 int res1 = 0 ;
19406 PyObject * obj0 = 0 ;
19407 char * kwnames[] = {
19408 (char *) "provider", NULL
19409 };
19410
19411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19413 if (!SWIG_IsOK(res1)) {
19414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19415 }
19416 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19417 {
19418 PyThreadState* __tstate = wxPyBeginAllowThreads();
19419 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 {
19424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19425 }
19426 return resultobj;
19427 fail:
19428 return NULL;
19429 }
19430
19431
19432 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj = 0;
19434 wxString *arg1 = 0 ;
19435 wxString const &arg2_defvalue = wxPyART_OTHER ;
19436 wxString *arg2 = (wxString *) &arg2_defvalue ;
19437 wxSize const &arg3_defvalue = wxDefaultSize ;
19438 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19439 wxBitmap result;
19440 bool temp1 = false ;
19441 bool temp2 = false ;
19442 wxSize temp3 ;
19443 PyObject * obj0 = 0 ;
19444 PyObject * obj1 = 0 ;
19445 PyObject * obj2 = 0 ;
19446 char * kwnames[] = {
19447 (char *) "id",(char *) "client",(char *) "size", NULL
19448 };
19449
19450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19451 {
19452 arg1 = wxString_in_helper(obj0);
19453 if (arg1 == NULL) SWIG_fail;
19454 temp1 = true;
19455 }
19456 if (obj1) {
19457 {
19458 arg2 = wxString_in_helper(obj1);
19459 if (arg2 == NULL) SWIG_fail;
19460 temp2 = true;
19461 }
19462 }
19463 if (obj2) {
19464 {
19465 arg3 = &temp3;
19466 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19467 }
19468 }
19469 {
19470 if (!wxPyCheckForApp()) SWIG_fail;
19471 PyThreadState* __tstate = wxPyBeginAllowThreads();
19472 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19473 wxPyEndAllowThreads(__tstate);
19474 if (PyErr_Occurred()) SWIG_fail;
19475 }
19476 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19477 {
19478 if (temp1)
19479 delete arg1;
19480 }
19481 {
19482 if (temp2)
19483 delete arg2;
19484 }
19485 return resultobj;
19486 fail:
19487 {
19488 if (temp1)
19489 delete arg1;
19490 }
19491 {
19492 if (temp2)
19493 delete arg2;
19494 }
19495 return NULL;
19496 }
19497
19498
19499 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19500 PyObject *resultobj = 0;
19501 wxString *arg1 = 0 ;
19502 wxString const &arg2_defvalue = wxPyART_OTHER ;
19503 wxString *arg2 = (wxString *) &arg2_defvalue ;
19504 wxSize const &arg3_defvalue = wxDefaultSize ;
19505 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19506 wxIcon result;
19507 bool temp1 = false ;
19508 bool temp2 = false ;
19509 wxSize temp3 ;
19510 PyObject * obj0 = 0 ;
19511 PyObject * obj1 = 0 ;
19512 PyObject * obj2 = 0 ;
19513 char * kwnames[] = {
19514 (char *) "id",(char *) "client",(char *) "size", NULL
19515 };
19516
19517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19518 {
19519 arg1 = wxString_in_helper(obj0);
19520 if (arg1 == NULL) SWIG_fail;
19521 temp1 = true;
19522 }
19523 if (obj1) {
19524 {
19525 arg2 = wxString_in_helper(obj1);
19526 if (arg2 == NULL) SWIG_fail;
19527 temp2 = true;
19528 }
19529 }
19530 if (obj2) {
19531 {
19532 arg3 = &temp3;
19533 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19534 }
19535 }
19536 {
19537 if (!wxPyCheckForApp()) SWIG_fail;
19538 PyThreadState* __tstate = wxPyBeginAllowThreads();
19539 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19540 wxPyEndAllowThreads(__tstate);
19541 if (PyErr_Occurred()) SWIG_fail;
19542 }
19543 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19544 {
19545 if (temp1)
19546 delete arg1;
19547 }
19548 {
19549 if (temp2)
19550 delete arg2;
19551 }
19552 return resultobj;
19553 fail:
19554 {
19555 if (temp1)
19556 delete arg1;
19557 }
19558 {
19559 if (temp2)
19560 delete arg2;
19561 }
19562 return NULL;
19563 }
19564
19565
19566 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19567 PyObject *resultobj = 0;
19568 wxString *arg1 = 0 ;
19569 bool arg2 = (bool) false ;
19570 wxSize result;
19571 bool temp1 = false ;
19572 bool val2 ;
19573 int ecode2 = 0 ;
19574 PyObject * obj0 = 0 ;
19575 PyObject * obj1 = 0 ;
19576 char * kwnames[] = {
19577 (char *) "client",(char *) "platform_dependent", NULL
19578 };
19579
19580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19581 {
19582 arg1 = wxString_in_helper(obj0);
19583 if (arg1 == NULL) SWIG_fail;
19584 temp1 = true;
19585 }
19586 if (obj1) {
19587 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19588 if (!SWIG_IsOK(ecode2)) {
19589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19590 }
19591 arg2 = static_cast< bool >(val2);
19592 }
19593 {
19594 PyThreadState* __tstate = wxPyBeginAllowThreads();
19595 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19596 wxPyEndAllowThreads(__tstate);
19597 if (PyErr_Occurred()) SWIG_fail;
19598 }
19599 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19600 {
19601 if (temp1)
19602 delete arg1;
19603 }
19604 return resultobj;
19605 fail:
19606 {
19607 if (temp1)
19608 delete arg1;
19609 }
19610 return NULL;
19611 }
19612
19613
19614 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19615 PyObject *resultobj = 0;
19616 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19617 void *argp1 = 0 ;
19618 int res1 = 0 ;
19619 PyObject *swig_obj[1] ;
19620
19621 if (!args) SWIG_fail;
19622 swig_obj[0] = args;
19623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19624 if (!SWIG_IsOK(res1)) {
19625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19626 }
19627 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 wxPyArtProvider_Destroy(arg1);
19631 wxPyEndAllowThreads(__tstate);
19632 if (PyErr_Occurred()) SWIG_fail;
19633 }
19634 resultobj = SWIG_Py_Void();
19635 return resultobj;
19636 fail:
19637 return NULL;
19638 }
19639
19640
19641 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19642 PyObject *obj;
19643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19644 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19645 return SWIG_Py_Void();
19646 }
19647
19648 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19649 return SWIG_Python_InitShadowInstance(args);
19650 }
19651
19652 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19653 PyObject *resultobj = 0;
19654 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19655 void *argp1 = 0 ;
19656 int res1 = 0 ;
19657 PyObject *swig_obj[1] ;
19658
19659 if (!args) SWIG_fail;
19660 swig_obj[0] = args;
19661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19662 if (!SWIG_IsOK(res1)) {
19663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19664 }
19665 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19666 {
19667 PyThreadState* __tstate = wxPyBeginAllowThreads();
19668 delete arg1;
19669
19670 wxPyEndAllowThreads(__tstate);
19671 if (PyErr_Occurred()) SWIG_fail;
19672 }
19673 resultobj = SWIG_Py_Void();
19674 return resultobj;
19675 fail:
19676 return NULL;
19677 }
19678
19679
19680 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19681 PyObject *resultobj = 0;
19682 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19683 wxConfigBase *result = 0 ;
19684 int res1 = 0 ;
19685 PyObject * obj0 = 0 ;
19686 char * kwnames[] = {
19687 (char *) "config", NULL
19688 };
19689
19690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19691 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19692 if (!SWIG_IsOK(res1)) {
19693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19694 }
19695 {
19696 PyThreadState* __tstate = wxPyBeginAllowThreads();
19697 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19698 wxPyEndAllowThreads(__tstate);
19699 if (PyErr_Occurred()) SWIG_fail;
19700 }
19701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19702 return resultobj;
19703 fail:
19704 return NULL;
19705 }
19706
19707
19708 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19709 PyObject *resultobj = 0;
19710 bool arg1 = (bool) true ;
19711 wxConfigBase *result = 0 ;
19712 bool val1 ;
19713 int ecode1 = 0 ;
19714 PyObject * obj0 = 0 ;
19715 char * kwnames[] = {
19716 (char *) "createOnDemand", NULL
19717 };
19718
19719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19720 if (obj0) {
19721 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19722 if (!SWIG_IsOK(ecode1)) {
19723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19724 }
19725 arg1 = static_cast< bool >(val1);
19726 }
19727 {
19728 PyThreadState* __tstate = wxPyBeginAllowThreads();
19729 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19730 wxPyEndAllowThreads(__tstate);
19731 if (PyErr_Occurred()) SWIG_fail;
19732 }
19733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19734 return resultobj;
19735 fail:
19736 return NULL;
19737 }
19738
19739
19740 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19741 PyObject *resultobj = 0;
19742 wxConfigBase *result = 0 ;
19743
19744 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19745 {
19746 PyThreadState* __tstate = wxPyBeginAllowThreads();
19747 result = (wxConfigBase *)wxConfigBase::Create();
19748 wxPyEndAllowThreads(__tstate);
19749 if (PyErr_Occurred()) SWIG_fail;
19750 }
19751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19752 return resultobj;
19753 fail:
19754 return NULL;
19755 }
19756
19757
19758 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19759 PyObject *resultobj = 0;
19760
19761 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19762 {
19763 PyThreadState* __tstate = wxPyBeginAllowThreads();
19764 wxConfigBase::DontCreateOnDemand();
19765 wxPyEndAllowThreads(__tstate);
19766 if (PyErr_Occurred()) SWIG_fail;
19767 }
19768 resultobj = SWIG_Py_Void();
19769 return resultobj;
19770 fail:
19771 return NULL;
19772 }
19773
19774
19775 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj = 0;
19777 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19778 wxString *arg2 = 0 ;
19779 void *argp1 = 0 ;
19780 int res1 = 0 ;
19781 bool temp2 = false ;
19782 PyObject * obj0 = 0 ;
19783 PyObject * obj1 = 0 ;
19784 char * kwnames[] = {
19785 (char *) "self",(char *) "path", NULL
19786 };
19787
19788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19790 if (!SWIG_IsOK(res1)) {
19791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19792 }
19793 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19794 {
19795 arg2 = wxString_in_helper(obj1);
19796 if (arg2 == NULL) SWIG_fail;
19797 temp2 = true;
19798 }
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 (arg1)->SetPath((wxString const &)*arg2);
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 resultobj = SWIG_Py_Void();
19806 {
19807 if (temp2)
19808 delete arg2;
19809 }
19810 return resultobj;
19811 fail:
19812 {
19813 if (temp2)
19814 delete arg2;
19815 }
19816 return NULL;
19817 }
19818
19819
19820 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19821 PyObject *resultobj = 0;
19822 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19823 wxString *result = 0 ;
19824 void *argp1 = 0 ;
19825 int res1 = 0 ;
19826 PyObject *swig_obj[1] ;
19827
19828 if (!args) SWIG_fail;
19829 swig_obj[0] = args;
19830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19831 if (!SWIG_IsOK(res1)) {
19832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19833 }
19834 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19835 {
19836 PyThreadState* __tstate = wxPyBeginAllowThreads();
19837 {
19838 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19839 result = (wxString *) &_result_ref;
19840 }
19841 wxPyEndAllowThreads(__tstate);
19842 if (PyErr_Occurred()) SWIG_fail;
19843 }
19844 {
19845 #if wxUSE_UNICODE
19846 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19847 #else
19848 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19849 #endif
19850 }
19851 return resultobj;
19852 fail:
19853 return NULL;
19854 }
19855
19856
19857 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19858 PyObject *resultobj = 0;
19859 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19860 PyObject *result = 0 ;
19861 void *argp1 = 0 ;
19862 int res1 = 0 ;
19863 PyObject *swig_obj[1] ;
19864
19865 if (!args) SWIG_fail;
19866 swig_obj[0] = args;
19867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19868 if (!SWIG_IsOK(res1)) {
19869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19870 }
19871 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19872 {
19873 PyThreadState* __tstate = wxPyBeginAllowThreads();
19874 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19875 wxPyEndAllowThreads(__tstate);
19876 if (PyErr_Occurred()) SWIG_fail;
19877 }
19878 resultobj = result;
19879 return resultobj;
19880 fail:
19881 return NULL;
19882 }
19883
19884
19885 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19886 PyObject *resultobj = 0;
19887 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19888 long arg2 ;
19889 PyObject *result = 0 ;
19890 void *argp1 = 0 ;
19891 int res1 = 0 ;
19892 long val2 ;
19893 int ecode2 = 0 ;
19894 PyObject * obj0 = 0 ;
19895 PyObject * obj1 = 0 ;
19896 char * kwnames[] = {
19897 (char *) "self",(char *) "index", NULL
19898 };
19899
19900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19902 if (!SWIG_IsOK(res1)) {
19903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19904 }
19905 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19906 ecode2 = SWIG_AsVal_long(obj1, &val2);
19907 if (!SWIG_IsOK(ecode2)) {
19908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19909 }
19910 arg2 = static_cast< long >(val2);
19911 {
19912 PyThreadState* __tstate = wxPyBeginAllowThreads();
19913 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19914 wxPyEndAllowThreads(__tstate);
19915 if (PyErr_Occurred()) SWIG_fail;
19916 }
19917 resultobj = result;
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19925 PyObject *resultobj = 0;
19926 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19927 PyObject *result = 0 ;
19928 void *argp1 = 0 ;
19929 int res1 = 0 ;
19930 PyObject *swig_obj[1] ;
19931
19932 if (!args) SWIG_fail;
19933 swig_obj[0] = args;
19934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19935 if (!SWIG_IsOK(res1)) {
19936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19937 }
19938 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19939 {
19940 PyThreadState* __tstate = wxPyBeginAllowThreads();
19941 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19942 wxPyEndAllowThreads(__tstate);
19943 if (PyErr_Occurred()) SWIG_fail;
19944 }
19945 resultobj = result;
19946 return resultobj;
19947 fail:
19948 return NULL;
19949 }
19950
19951
19952 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19953 PyObject *resultobj = 0;
19954 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19955 long arg2 ;
19956 PyObject *result = 0 ;
19957 void *argp1 = 0 ;
19958 int res1 = 0 ;
19959 long val2 ;
19960 int ecode2 = 0 ;
19961 PyObject * obj0 = 0 ;
19962 PyObject * obj1 = 0 ;
19963 char * kwnames[] = {
19964 (char *) "self",(char *) "index", NULL
19965 };
19966
19967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19969 if (!SWIG_IsOK(res1)) {
19970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19971 }
19972 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19973 ecode2 = SWIG_AsVal_long(obj1, &val2);
19974 if (!SWIG_IsOK(ecode2)) {
19975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19976 }
19977 arg2 = static_cast< long >(val2);
19978 {
19979 PyThreadState* __tstate = wxPyBeginAllowThreads();
19980 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19981 wxPyEndAllowThreads(__tstate);
19982 if (PyErr_Occurred()) SWIG_fail;
19983 }
19984 resultobj = result;
19985 return resultobj;
19986 fail:
19987 return NULL;
19988 }
19989
19990
19991 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19992 PyObject *resultobj = 0;
19993 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19994 bool arg2 = (bool) false ;
19995 size_t result;
19996 void *argp1 = 0 ;
19997 int res1 = 0 ;
19998 bool val2 ;
19999 int ecode2 = 0 ;
20000 PyObject * obj0 = 0 ;
20001 PyObject * obj1 = 0 ;
20002 char * kwnames[] = {
20003 (char *) "self",(char *) "recursive", NULL
20004 };
20005
20006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
20007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20008 if (!SWIG_IsOK(res1)) {
20009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20010 }
20011 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20012 if (obj1) {
20013 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20014 if (!SWIG_IsOK(ecode2)) {
20015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20016 }
20017 arg2 = static_cast< bool >(val2);
20018 }
20019 {
20020 PyThreadState* __tstate = wxPyBeginAllowThreads();
20021 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20022 wxPyEndAllowThreads(__tstate);
20023 if (PyErr_Occurred()) SWIG_fail;
20024 }
20025 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20026 return resultobj;
20027 fail:
20028 return NULL;
20029 }
20030
20031
20032 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20033 PyObject *resultobj = 0;
20034 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20035 bool arg2 = (bool) false ;
20036 size_t result;
20037 void *argp1 = 0 ;
20038 int res1 = 0 ;
20039 bool val2 ;
20040 int ecode2 = 0 ;
20041 PyObject * obj0 = 0 ;
20042 PyObject * obj1 = 0 ;
20043 char * kwnames[] = {
20044 (char *) "self",(char *) "recursive", NULL
20045 };
20046
20047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
20048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20049 if (!SWIG_IsOK(res1)) {
20050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20051 }
20052 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20053 if (obj1) {
20054 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20055 if (!SWIG_IsOK(ecode2)) {
20056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
20057 }
20058 arg2 = static_cast< bool >(val2);
20059 }
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20067 return resultobj;
20068 fail:
20069 return NULL;
20070 }
20071
20072
20073 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20074 PyObject *resultobj = 0;
20075 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20076 wxString *arg2 = 0 ;
20077 bool result;
20078 void *argp1 = 0 ;
20079 int res1 = 0 ;
20080 bool temp2 = false ;
20081 PyObject * obj0 = 0 ;
20082 PyObject * obj1 = 0 ;
20083 char * kwnames[] = {
20084 (char *) "self",(char *) "name", NULL
20085 };
20086
20087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20089 if (!SWIG_IsOK(res1)) {
20090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20091 }
20092 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20093 {
20094 arg2 = wxString_in_helper(obj1);
20095 if (arg2 == NULL) SWIG_fail;
20096 temp2 = true;
20097 }
20098 {
20099 PyThreadState* __tstate = wxPyBeginAllowThreads();
20100 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
20101 wxPyEndAllowThreads(__tstate);
20102 if (PyErr_Occurred()) SWIG_fail;
20103 }
20104 {
20105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20106 }
20107 {
20108 if (temp2)
20109 delete arg2;
20110 }
20111 return resultobj;
20112 fail:
20113 {
20114 if (temp2)
20115 delete arg2;
20116 }
20117 return NULL;
20118 }
20119
20120
20121 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20122 PyObject *resultobj = 0;
20123 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20124 wxString *arg2 = 0 ;
20125 bool result;
20126 void *argp1 = 0 ;
20127 int res1 = 0 ;
20128 bool temp2 = false ;
20129 PyObject * obj0 = 0 ;
20130 PyObject * obj1 = 0 ;
20131 char * kwnames[] = {
20132 (char *) "self",(char *) "name", NULL
20133 };
20134
20135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20137 if (!SWIG_IsOK(res1)) {
20138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20139 }
20140 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20141 {
20142 arg2 = wxString_in_helper(obj1);
20143 if (arg2 == NULL) SWIG_fail;
20144 temp2 = true;
20145 }
20146 {
20147 PyThreadState* __tstate = wxPyBeginAllowThreads();
20148 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20149 wxPyEndAllowThreads(__tstate);
20150 if (PyErr_Occurred()) SWIG_fail;
20151 }
20152 {
20153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20154 }
20155 {
20156 if (temp2)
20157 delete arg2;
20158 }
20159 return resultobj;
20160 fail:
20161 {
20162 if (temp2)
20163 delete arg2;
20164 }
20165 return NULL;
20166 }
20167
20168
20169 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20170 PyObject *resultobj = 0;
20171 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20172 wxString *arg2 = 0 ;
20173 bool result;
20174 void *argp1 = 0 ;
20175 int res1 = 0 ;
20176 bool temp2 = false ;
20177 PyObject * obj0 = 0 ;
20178 PyObject * obj1 = 0 ;
20179 char * kwnames[] = {
20180 (char *) "self",(char *) "name", NULL
20181 };
20182
20183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20185 if (!SWIG_IsOK(res1)) {
20186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20187 }
20188 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20189 {
20190 arg2 = wxString_in_helper(obj1);
20191 if (arg2 == NULL) SWIG_fail;
20192 temp2 = true;
20193 }
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 {
20201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20202 }
20203 {
20204 if (temp2)
20205 delete arg2;
20206 }
20207 return resultobj;
20208 fail:
20209 {
20210 if (temp2)
20211 delete arg2;
20212 }
20213 return NULL;
20214 }
20215
20216
20217 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20218 PyObject *resultobj = 0;
20219 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20220 wxString *arg2 = 0 ;
20221 wxConfigBase::EntryType result;
20222 void *argp1 = 0 ;
20223 int res1 = 0 ;
20224 bool temp2 = false ;
20225 PyObject * obj0 = 0 ;
20226 PyObject * obj1 = 0 ;
20227 char * kwnames[] = {
20228 (char *) "self",(char *) "name", NULL
20229 };
20230
20231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20233 if (!SWIG_IsOK(res1)) {
20234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20235 }
20236 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20237 {
20238 arg2 = wxString_in_helper(obj1);
20239 if (arg2 == NULL) SWIG_fail;
20240 temp2 = true;
20241 }
20242 {
20243 PyThreadState* __tstate = wxPyBeginAllowThreads();
20244 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20245 wxPyEndAllowThreads(__tstate);
20246 if (PyErr_Occurred()) SWIG_fail;
20247 }
20248 resultobj = SWIG_From_int(static_cast< int >(result));
20249 {
20250 if (temp2)
20251 delete arg2;
20252 }
20253 return resultobj;
20254 fail:
20255 {
20256 if (temp2)
20257 delete arg2;
20258 }
20259 return NULL;
20260 }
20261
20262
20263 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20264 PyObject *resultobj = 0;
20265 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20266 wxString *arg2 = 0 ;
20267 wxString const &arg3_defvalue = wxPyEmptyString ;
20268 wxString *arg3 = (wxString *) &arg3_defvalue ;
20269 wxString result;
20270 void *argp1 = 0 ;
20271 int res1 = 0 ;
20272 bool temp2 = false ;
20273 bool temp3 = false ;
20274 PyObject * obj0 = 0 ;
20275 PyObject * obj1 = 0 ;
20276 PyObject * obj2 = 0 ;
20277 char * kwnames[] = {
20278 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20279 };
20280
20281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20283 if (!SWIG_IsOK(res1)) {
20284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20285 }
20286 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20287 {
20288 arg2 = wxString_in_helper(obj1);
20289 if (arg2 == NULL) SWIG_fail;
20290 temp2 = true;
20291 }
20292 if (obj2) {
20293 {
20294 arg3 = wxString_in_helper(obj2);
20295 if (arg3 == NULL) SWIG_fail;
20296 temp3 = true;
20297 }
20298 }
20299 {
20300 PyThreadState* __tstate = wxPyBeginAllowThreads();
20301 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20302 wxPyEndAllowThreads(__tstate);
20303 if (PyErr_Occurred()) SWIG_fail;
20304 }
20305 {
20306 #if wxUSE_UNICODE
20307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20308 #else
20309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20310 #endif
20311 }
20312 {
20313 if (temp2)
20314 delete arg2;
20315 }
20316 {
20317 if (temp3)
20318 delete arg3;
20319 }
20320 return resultobj;
20321 fail:
20322 {
20323 if (temp2)
20324 delete arg2;
20325 }
20326 {
20327 if (temp3)
20328 delete arg3;
20329 }
20330 return NULL;
20331 }
20332
20333
20334 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20335 PyObject *resultobj = 0;
20336 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20337 wxString *arg2 = 0 ;
20338 long arg3 = (long) 0 ;
20339 long result;
20340 void *argp1 = 0 ;
20341 int res1 = 0 ;
20342 bool temp2 = false ;
20343 long val3 ;
20344 int ecode3 = 0 ;
20345 PyObject * obj0 = 0 ;
20346 PyObject * obj1 = 0 ;
20347 PyObject * obj2 = 0 ;
20348 char * kwnames[] = {
20349 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20350 };
20351
20352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20354 if (!SWIG_IsOK(res1)) {
20355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20356 }
20357 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20358 {
20359 arg2 = wxString_in_helper(obj1);
20360 if (arg2 == NULL) SWIG_fail;
20361 temp2 = true;
20362 }
20363 if (obj2) {
20364 ecode3 = SWIG_AsVal_long(obj2, &val3);
20365 if (!SWIG_IsOK(ecode3)) {
20366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20367 }
20368 arg3 = static_cast< long >(val3);
20369 }
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20373 wxPyEndAllowThreads(__tstate);
20374 if (PyErr_Occurred()) SWIG_fail;
20375 }
20376 resultobj = SWIG_From_long(static_cast< long >(result));
20377 {
20378 if (temp2)
20379 delete arg2;
20380 }
20381 return resultobj;
20382 fail:
20383 {
20384 if (temp2)
20385 delete arg2;
20386 }
20387 return NULL;
20388 }
20389
20390
20391 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20392 PyObject *resultobj = 0;
20393 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20394 wxString *arg2 = 0 ;
20395 double arg3 = (double) 0.0 ;
20396 double result;
20397 void *argp1 = 0 ;
20398 int res1 = 0 ;
20399 bool temp2 = false ;
20400 double val3 ;
20401 int ecode3 = 0 ;
20402 PyObject * obj0 = 0 ;
20403 PyObject * obj1 = 0 ;
20404 PyObject * obj2 = 0 ;
20405 char * kwnames[] = {
20406 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20407 };
20408
20409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20411 if (!SWIG_IsOK(res1)) {
20412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20413 }
20414 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20415 {
20416 arg2 = wxString_in_helper(obj1);
20417 if (arg2 == NULL) SWIG_fail;
20418 temp2 = true;
20419 }
20420 if (obj2) {
20421 ecode3 = SWIG_AsVal_double(obj2, &val3);
20422 if (!SWIG_IsOK(ecode3)) {
20423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20424 }
20425 arg3 = static_cast< double >(val3);
20426 }
20427 {
20428 PyThreadState* __tstate = wxPyBeginAllowThreads();
20429 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20430 wxPyEndAllowThreads(__tstate);
20431 if (PyErr_Occurred()) SWIG_fail;
20432 }
20433 resultobj = SWIG_From_double(static_cast< double >(result));
20434 {
20435 if (temp2)
20436 delete arg2;
20437 }
20438 return resultobj;
20439 fail:
20440 {
20441 if (temp2)
20442 delete arg2;
20443 }
20444 return NULL;
20445 }
20446
20447
20448 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20449 PyObject *resultobj = 0;
20450 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20451 wxString *arg2 = 0 ;
20452 bool arg3 = (bool) false ;
20453 bool result;
20454 void *argp1 = 0 ;
20455 int res1 = 0 ;
20456 bool temp2 = false ;
20457 bool val3 ;
20458 int ecode3 = 0 ;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 PyObject * obj2 = 0 ;
20462 char * kwnames[] = {
20463 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20464 };
20465
20466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20468 if (!SWIG_IsOK(res1)) {
20469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20470 }
20471 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20472 {
20473 arg2 = wxString_in_helper(obj1);
20474 if (arg2 == NULL) SWIG_fail;
20475 temp2 = true;
20476 }
20477 if (obj2) {
20478 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20479 if (!SWIG_IsOK(ecode3)) {
20480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20481 }
20482 arg3 = static_cast< bool >(val3);
20483 }
20484 {
20485 PyThreadState* __tstate = wxPyBeginAllowThreads();
20486 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20487 wxPyEndAllowThreads(__tstate);
20488 if (PyErr_Occurred()) SWIG_fail;
20489 }
20490 {
20491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20492 }
20493 {
20494 if (temp2)
20495 delete arg2;
20496 }
20497 return resultobj;
20498 fail:
20499 {
20500 if (temp2)
20501 delete arg2;
20502 }
20503 return NULL;
20504 }
20505
20506
20507 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20508 PyObject *resultobj = 0;
20509 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20510 wxString *arg2 = 0 ;
20511 wxString *arg3 = 0 ;
20512 bool result;
20513 void *argp1 = 0 ;
20514 int res1 = 0 ;
20515 bool temp2 = false ;
20516 bool temp3 = false ;
20517 PyObject * obj0 = 0 ;
20518 PyObject * obj1 = 0 ;
20519 PyObject * obj2 = 0 ;
20520 char * kwnames[] = {
20521 (char *) "self",(char *) "key",(char *) "value", NULL
20522 };
20523
20524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20526 if (!SWIG_IsOK(res1)) {
20527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20528 }
20529 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20530 {
20531 arg2 = wxString_in_helper(obj1);
20532 if (arg2 == NULL) SWIG_fail;
20533 temp2 = true;
20534 }
20535 {
20536 arg3 = wxString_in_helper(obj2);
20537 if (arg3 == NULL) SWIG_fail;
20538 temp3 = true;
20539 }
20540 {
20541 PyThreadState* __tstate = wxPyBeginAllowThreads();
20542 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20543 wxPyEndAllowThreads(__tstate);
20544 if (PyErr_Occurred()) SWIG_fail;
20545 }
20546 {
20547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20548 }
20549 {
20550 if (temp2)
20551 delete arg2;
20552 }
20553 {
20554 if (temp3)
20555 delete arg3;
20556 }
20557 return resultobj;
20558 fail:
20559 {
20560 if (temp2)
20561 delete arg2;
20562 }
20563 {
20564 if (temp3)
20565 delete arg3;
20566 }
20567 return NULL;
20568 }
20569
20570
20571 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20572 PyObject *resultobj = 0;
20573 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20574 wxString *arg2 = 0 ;
20575 long arg3 ;
20576 bool result;
20577 void *argp1 = 0 ;
20578 int res1 = 0 ;
20579 bool temp2 = false ;
20580 long val3 ;
20581 int ecode3 = 0 ;
20582 PyObject * obj0 = 0 ;
20583 PyObject * obj1 = 0 ;
20584 PyObject * obj2 = 0 ;
20585 char * kwnames[] = {
20586 (char *) "self",(char *) "key",(char *) "value", NULL
20587 };
20588
20589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20591 if (!SWIG_IsOK(res1)) {
20592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20593 }
20594 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20595 {
20596 arg2 = wxString_in_helper(obj1);
20597 if (arg2 == NULL) SWIG_fail;
20598 temp2 = true;
20599 }
20600 ecode3 = SWIG_AsVal_long(obj2, &val3);
20601 if (!SWIG_IsOK(ecode3)) {
20602 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20603 }
20604 arg3 = static_cast< long >(val3);
20605 {
20606 PyThreadState* __tstate = wxPyBeginAllowThreads();
20607 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20608 wxPyEndAllowThreads(__tstate);
20609 if (PyErr_Occurred()) SWIG_fail;
20610 }
20611 {
20612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20613 }
20614 {
20615 if (temp2)
20616 delete arg2;
20617 }
20618 return resultobj;
20619 fail:
20620 {
20621 if (temp2)
20622 delete arg2;
20623 }
20624 return NULL;
20625 }
20626
20627
20628 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20629 PyObject *resultobj = 0;
20630 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20631 wxString *arg2 = 0 ;
20632 double arg3 ;
20633 bool result;
20634 void *argp1 = 0 ;
20635 int res1 = 0 ;
20636 bool temp2 = false ;
20637 double val3 ;
20638 int ecode3 = 0 ;
20639 PyObject * obj0 = 0 ;
20640 PyObject * obj1 = 0 ;
20641 PyObject * obj2 = 0 ;
20642 char * kwnames[] = {
20643 (char *) "self",(char *) "key",(char *) "value", NULL
20644 };
20645
20646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20648 if (!SWIG_IsOK(res1)) {
20649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20650 }
20651 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20652 {
20653 arg2 = wxString_in_helper(obj1);
20654 if (arg2 == NULL) SWIG_fail;
20655 temp2 = true;
20656 }
20657 ecode3 = SWIG_AsVal_double(obj2, &val3);
20658 if (!SWIG_IsOK(ecode3)) {
20659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20660 }
20661 arg3 = static_cast< double >(val3);
20662 {
20663 PyThreadState* __tstate = wxPyBeginAllowThreads();
20664 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20665 wxPyEndAllowThreads(__tstate);
20666 if (PyErr_Occurred()) SWIG_fail;
20667 }
20668 {
20669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20670 }
20671 {
20672 if (temp2)
20673 delete arg2;
20674 }
20675 return resultobj;
20676 fail:
20677 {
20678 if (temp2)
20679 delete arg2;
20680 }
20681 return NULL;
20682 }
20683
20684
20685 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20686 PyObject *resultobj = 0;
20687 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20688 wxString *arg2 = 0 ;
20689 bool arg3 ;
20690 bool result;
20691 void *argp1 = 0 ;
20692 int res1 = 0 ;
20693 bool temp2 = false ;
20694 bool val3 ;
20695 int ecode3 = 0 ;
20696 PyObject * obj0 = 0 ;
20697 PyObject * obj1 = 0 ;
20698 PyObject * obj2 = 0 ;
20699 char * kwnames[] = {
20700 (char *) "self",(char *) "key",(char *) "value", NULL
20701 };
20702
20703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20705 if (!SWIG_IsOK(res1)) {
20706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20707 }
20708 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20709 {
20710 arg2 = wxString_in_helper(obj1);
20711 if (arg2 == NULL) SWIG_fail;
20712 temp2 = true;
20713 }
20714 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20715 if (!SWIG_IsOK(ecode3)) {
20716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20717 }
20718 arg3 = static_cast< bool >(val3);
20719 {
20720 PyThreadState* __tstate = wxPyBeginAllowThreads();
20721 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20722 wxPyEndAllowThreads(__tstate);
20723 if (PyErr_Occurred()) SWIG_fail;
20724 }
20725 {
20726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20727 }
20728 {
20729 if (temp2)
20730 delete arg2;
20731 }
20732 return resultobj;
20733 fail:
20734 {
20735 if (temp2)
20736 delete arg2;
20737 }
20738 return NULL;
20739 }
20740
20741
20742 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20743 PyObject *resultobj = 0;
20744 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20745 bool arg2 = (bool) false ;
20746 bool result;
20747 void *argp1 = 0 ;
20748 int res1 = 0 ;
20749 bool val2 ;
20750 int ecode2 = 0 ;
20751 PyObject * obj0 = 0 ;
20752 PyObject * obj1 = 0 ;
20753 char * kwnames[] = {
20754 (char *) "self",(char *) "currentOnly", NULL
20755 };
20756
20757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20759 if (!SWIG_IsOK(res1)) {
20760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20761 }
20762 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20763 if (obj1) {
20764 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20765 if (!SWIG_IsOK(ecode2)) {
20766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20767 }
20768 arg2 = static_cast< bool >(val2);
20769 }
20770 {
20771 PyThreadState* __tstate = wxPyBeginAllowThreads();
20772 result = (bool)(arg1)->Flush(arg2);
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 {
20777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20778 }
20779 return resultobj;
20780 fail:
20781 return NULL;
20782 }
20783
20784
20785 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20786 PyObject *resultobj = 0;
20787 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20788 wxString *arg2 = 0 ;
20789 wxString *arg3 = 0 ;
20790 bool result;
20791 void *argp1 = 0 ;
20792 int res1 = 0 ;
20793 bool temp2 = false ;
20794 bool temp3 = false ;
20795 PyObject * obj0 = 0 ;
20796 PyObject * obj1 = 0 ;
20797 PyObject * obj2 = 0 ;
20798 char * kwnames[] = {
20799 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20800 };
20801
20802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20804 if (!SWIG_IsOK(res1)) {
20805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20806 }
20807 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20808 {
20809 arg2 = wxString_in_helper(obj1);
20810 if (arg2 == NULL) SWIG_fail;
20811 temp2 = true;
20812 }
20813 {
20814 arg3 = wxString_in_helper(obj2);
20815 if (arg3 == NULL) SWIG_fail;
20816 temp3 = true;
20817 }
20818 {
20819 PyThreadState* __tstate = wxPyBeginAllowThreads();
20820 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20821 wxPyEndAllowThreads(__tstate);
20822 if (PyErr_Occurred()) SWIG_fail;
20823 }
20824 {
20825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20826 }
20827 {
20828 if (temp2)
20829 delete arg2;
20830 }
20831 {
20832 if (temp3)
20833 delete arg3;
20834 }
20835 return resultobj;
20836 fail:
20837 {
20838 if (temp2)
20839 delete arg2;
20840 }
20841 {
20842 if (temp3)
20843 delete arg3;
20844 }
20845 return NULL;
20846 }
20847
20848
20849 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20850 PyObject *resultobj = 0;
20851 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20852 wxString *arg2 = 0 ;
20853 wxString *arg3 = 0 ;
20854 bool result;
20855 void *argp1 = 0 ;
20856 int res1 = 0 ;
20857 bool temp2 = false ;
20858 bool temp3 = false ;
20859 PyObject * obj0 = 0 ;
20860 PyObject * obj1 = 0 ;
20861 PyObject * obj2 = 0 ;
20862 char * kwnames[] = {
20863 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20864 };
20865
20866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20868 if (!SWIG_IsOK(res1)) {
20869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20870 }
20871 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20872 {
20873 arg2 = wxString_in_helper(obj1);
20874 if (arg2 == NULL) SWIG_fail;
20875 temp2 = true;
20876 }
20877 {
20878 arg3 = wxString_in_helper(obj2);
20879 if (arg3 == NULL) SWIG_fail;
20880 temp3 = true;
20881 }
20882 {
20883 PyThreadState* __tstate = wxPyBeginAllowThreads();
20884 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20885 wxPyEndAllowThreads(__tstate);
20886 if (PyErr_Occurred()) SWIG_fail;
20887 }
20888 {
20889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20890 }
20891 {
20892 if (temp2)
20893 delete arg2;
20894 }
20895 {
20896 if (temp3)
20897 delete arg3;
20898 }
20899 return resultobj;
20900 fail:
20901 {
20902 if (temp2)
20903 delete arg2;
20904 }
20905 {
20906 if (temp3)
20907 delete arg3;
20908 }
20909 return NULL;
20910 }
20911
20912
20913 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20914 PyObject *resultobj = 0;
20915 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20916 wxString *arg2 = 0 ;
20917 bool arg3 = (bool) true ;
20918 bool result;
20919 void *argp1 = 0 ;
20920 int res1 = 0 ;
20921 bool temp2 = false ;
20922 bool val3 ;
20923 int ecode3 = 0 ;
20924 PyObject * obj0 = 0 ;
20925 PyObject * obj1 = 0 ;
20926 PyObject * obj2 = 0 ;
20927 char * kwnames[] = {
20928 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20929 };
20930
20931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20933 if (!SWIG_IsOK(res1)) {
20934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20935 }
20936 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20937 {
20938 arg2 = wxString_in_helper(obj1);
20939 if (arg2 == NULL) SWIG_fail;
20940 temp2 = true;
20941 }
20942 if (obj2) {
20943 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20944 if (!SWIG_IsOK(ecode3)) {
20945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20946 }
20947 arg3 = static_cast< bool >(val3);
20948 }
20949 {
20950 PyThreadState* __tstate = wxPyBeginAllowThreads();
20951 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 {
20956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20957 }
20958 {
20959 if (temp2)
20960 delete arg2;
20961 }
20962 return resultobj;
20963 fail:
20964 {
20965 if (temp2)
20966 delete arg2;
20967 }
20968 return NULL;
20969 }
20970
20971
20972 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20973 PyObject *resultobj = 0;
20974 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20975 wxString *arg2 = 0 ;
20976 bool result;
20977 void *argp1 = 0 ;
20978 int res1 = 0 ;
20979 bool temp2 = false ;
20980 PyObject * obj0 = 0 ;
20981 PyObject * obj1 = 0 ;
20982 char * kwnames[] = {
20983 (char *) "self",(char *) "key", NULL
20984 };
20985
20986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20988 if (!SWIG_IsOK(res1)) {
20989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20990 }
20991 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20992 {
20993 arg2 = wxString_in_helper(obj1);
20994 if (arg2 == NULL) SWIG_fail;
20995 temp2 = true;
20996 }
20997 {
20998 PyThreadState* __tstate = wxPyBeginAllowThreads();
20999 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
21000 wxPyEndAllowThreads(__tstate);
21001 if (PyErr_Occurred()) SWIG_fail;
21002 }
21003 {
21004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21005 }
21006 {
21007 if (temp2)
21008 delete arg2;
21009 }
21010 return resultobj;
21011 fail:
21012 {
21013 if (temp2)
21014 delete arg2;
21015 }
21016 return NULL;
21017 }
21018
21019
21020 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21021 PyObject *resultobj = 0;
21022 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21023 bool result;
21024 void *argp1 = 0 ;
21025 int res1 = 0 ;
21026 PyObject *swig_obj[1] ;
21027
21028 if (!args) SWIG_fail;
21029 swig_obj[0] = args;
21030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21031 if (!SWIG_IsOK(res1)) {
21032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21033 }
21034 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21035 {
21036 PyThreadState* __tstate = wxPyBeginAllowThreads();
21037 result = (bool)(arg1)->DeleteAll();
21038 wxPyEndAllowThreads(__tstate);
21039 if (PyErr_Occurred()) SWIG_fail;
21040 }
21041 {
21042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21043 }
21044 return resultobj;
21045 fail:
21046 return NULL;
21047 }
21048
21049
21050 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21051 PyObject *resultobj = 0;
21052 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21053 bool arg2 = (bool) true ;
21054 void *argp1 = 0 ;
21055 int res1 = 0 ;
21056 bool val2 ;
21057 int ecode2 = 0 ;
21058 PyObject * obj0 = 0 ;
21059 PyObject * obj1 = 0 ;
21060 char * kwnames[] = {
21061 (char *) "self",(char *) "doIt", NULL
21062 };
21063
21064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",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_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21068 }
21069 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21070 if (obj1) {
21071 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21072 if (!SWIG_IsOK(ecode2)) {
21073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
21074 }
21075 arg2 = static_cast< bool >(val2);
21076 }
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 (arg1)->SetExpandEnvVars(arg2);
21080 wxPyEndAllowThreads(__tstate);
21081 if (PyErr_Occurred()) SWIG_fail;
21082 }
21083 resultobj = SWIG_Py_Void();
21084 return resultobj;
21085 fail:
21086 return NULL;
21087 }
21088
21089
21090 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21091 PyObject *resultobj = 0;
21092 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21093 bool result;
21094 void *argp1 = 0 ;
21095 int res1 = 0 ;
21096 PyObject *swig_obj[1] ;
21097
21098 if (!args) SWIG_fail;
21099 swig_obj[0] = args;
21100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21101 if (!SWIG_IsOK(res1)) {
21102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21103 }
21104 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21105 {
21106 PyThreadState* __tstate = wxPyBeginAllowThreads();
21107 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
21108 wxPyEndAllowThreads(__tstate);
21109 if (PyErr_Occurred()) SWIG_fail;
21110 }
21111 {
21112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21113 }
21114 return resultobj;
21115 fail:
21116 return NULL;
21117 }
21118
21119
21120 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21121 PyObject *resultobj = 0;
21122 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21123 bool arg2 = (bool) true ;
21124 void *argp1 = 0 ;
21125 int res1 = 0 ;
21126 bool val2 ;
21127 int ecode2 = 0 ;
21128 PyObject * obj0 = 0 ;
21129 PyObject * obj1 = 0 ;
21130 char * kwnames[] = {
21131 (char *) "self",(char *) "doIt", NULL
21132 };
21133
21134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21136 if (!SWIG_IsOK(res1)) {
21137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21138 }
21139 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21140 if (obj1) {
21141 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21142 if (!SWIG_IsOK(ecode2)) {
21143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21144 }
21145 arg2 = static_cast< bool >(val2);
21146 }
21147 {
21148 PyThreadState* __tstate = wxPyBeginAllowThreads();
21149 (arg1)->SetRecordDefaults(arg2);
21150 wxPyEndAllowThreads(__tstate);
21151 if (PyErr_Occurred()) SWIG_fail;
21152 }
21153 resultobj = SWIG_Py_Void();
21154 return resultobj;
21155 fail:
21156 return NULL;
21157 }
21158
21159
21160 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21161 PyObject *resultobj = 0;
21162 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21163 bool result;
21164 void *argp1 = 0 ;
21165 int res1 = 0 ;
21166 PyObject *swig_obj[1] ;
21167
21168 if (!args) SWIG_fail;
21169 swig_obj[0] = args;
21170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21171 if (!SWIG_IsOK(res1)) {
21172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21173 }
21174 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21175 {
21176 PyThreadState* __tstate = wxPyBeginAllowThreads();
21177 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21178 wxPyEndAllowThreads(__tstate);
21179 if (PyErr_Occurred()) SWIG_fail;
21180 }
21181 {
21182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21183 }
21184 return resultobj;
21185 fail:
21186 return NULL;
21187 }
21188
21189
21190 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21191 PyObject *resultobj = 0;
21192 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21193 wxString *arg2 = 0 ;
21194 wxString result;
21195 void *argp1 = 0 ;
21196 int res1 = 0 ;
21197 bool temp2 = false ;
21198 PyObject * obj0 = 0 ;
21199 PyObject * obj1 = 0 ;
21200 char * kwnames[] = {
21201 (char *) "self",(char *) "str", NULL
21202 };
21203
21204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21206 if (!SWIG_IsOK(res1)) {
21207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21208 }
21209 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21210 {
21211 arg2 = wxString_in_helper(obj1);
21212 if (arg2 == NULL) SWIG_fail;
21213 temp2 = true;
21214 }
21215 {
21216 PyThreadState* __tstate = wxPyBeginAllowThreads();
21217 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21218 wxPyEndAllowThreads(__tstate);
21219 if (PyErr_Occurred()) SWIG_fail;
21220 }
21221 {
21222 #if wxUSE_UNICODE
21223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21224 #else
21225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21226 #endif
21227 }
21228 {
21229 if (temp2)
21230 delete arg2;
21231 }
21232 return resultobj;
21233 fail:
21234 {
21235 if (temp2)
21236 delete arg2;
21237 }
21238 return NULL;
21239 }
21240
21241
21242 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21243 PyObject *resultobj = 0;
21244 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21245 wxString result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 PyObject *swig_obj[1] ;
21249
21250 if (!args) SWIG_fail;
21251 swig_obj[0] = args;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21255 }
21256 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21257 {
21258 PyThreadState* __tstate = wxPyBeginAllowThreads();
21259 result = ((wxConfigBase const *)arg1)->GetAppName();
21260 wxPyEndAllowThreads(__tstate);
21261 if (PyErr_Occurred()) SWIG_fail;
21262 }
21263 {
21264 #if wxUSE_UNICODE
21265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21266 #else
21267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21268 #endif
21269 }
21270 return resultobj;
21271 fail:
21272 return NULL;
21273 }
21274
21275
21276 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21277 PyObject *resultobj = 0;
21278 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21279 wxString result;
21280 void *argp1 = 0 ;
21281 int res1 = 0 ;
21282 PyObject *swig_obj[1] ;
21283
21284 if (!args) SWIG_fail;
21285 swig_obj[0] = args;
21286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21287 if (!SWIG_IsOK(res1)) {
21288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21289 }
21290 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21291 {
21292 PyThreadState* __tstate = wxPyBeginAllowThreads();
21293 result = ((wxConfigBase const *)arg1)->GetVendorName();
21294 wxPyEndAllowThreads(__tstate);
21295 if (PyErr_Occurred()) SWIG_fail;
21296 }
21297 {
21298 #if wxUSE_UNICODE
21299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21300 #else
21301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21302 #endif
21303 }
21304 return resultobj;
21305 fail:
21306 return NULL;
21307 }
21308
21309
21310 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21311 PyObject *resultobj = 0;
21312 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21313 wxString *arg2 = 0 ;
21314 void *argp1 = 0 ;
21315 int res1 = 0 ;
21316 bool temp2 = false ;
21317 PyObject * obj0 = 0 ;
21318 PyObject * obj1 = 0 ;
21319 char * kwnames[] = {
21320 (char *) "self",(char *) "appName", NULL
21321 };
21322
21323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",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_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21327 }
21328 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21329 {
21330 arg2 = wxString_in_helper(obj1);
21331 if (arg2 == NULL) SWIG_fail;
21332 temp2 = true;
21333 }
21334 {
21335 PyThreadState* __tstate = wxPyBeginAllowThreads();
21336 (arg1)->SetAppName((wxString const &)*arg2);
21337 wxPyEndAllowThreads(__tstate);
21338 if (PyErr_Occurred()) SWIG_fail;
21339 }
21340 resultobj = SWIG_Py_Void();
21341 {
21342 if (temp2)
21343 delete arg2;
21344 }
21345 return resultobj;
21346 fail:
21347 {
21348 if (temp2)
21349 delete arg2;
21350 }
21351 return NULL;
21352 }
21353
21354
21355 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21356 PyObject *resultobj = 0;
21357 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21358 wxString *arg2 = 0 ;
21359 void *argp1 = 0 ;
21360 int res1 = 0 ;
21361 bool temp2 = false ;
21362 PyObject * obj0 = 0 ;
21363 PyObject * obj1 = 0 ;
21364 char * kwnames[] = {
21365 (char *) "self",(char *) "vendorName", NULL
21366 };
21367
21368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21370 if (!SWIG_IsOK(res1)) {
21371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21372 }
21373 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21374 {
21375 arg2 = wxString_in_helper(obj1);
21376 if (arg2 == NULL) SWIG_fail;
21377 temp2 = true;
21378 }
21379 {
21380 PyThreadState* __tstate = wxPyBeginAllowThreads();
21381 (arg1)->SetVendorName((wxString const &)*arg2);
21382 wxPyEndAllowThreads(__tstate);
21383 if (PyErr_Occurred()) SWIG_fail;
21384 }
21385 resultobj = SWIG_Py_Void();
21386 {
21387 if (temp2)
21388 delete arg2;
21389 }
21390 return resultobj;
21391 fail:
21392 {
21393 if (temp2)
21394 delete arg2;
21395 }
21396 return NULL;
21397 }
21398
21399
21400 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21401 PyObject *resultobj = 0;
21402 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21403 long arg2 ;
21404 void *argp1 = 0 ;
21405 int res1 = 0 ;
21406 long val2 ;
21407 int ecode2 = 0 ;
21408 PyObject * obj0 = 0 ;
21409 PyObject * obj1 = 0 ;
21410 char * kwnames[] = {
21411 (char *) "self",(char *) "style", NULL
21412 };
21413
21414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21416 if (!SWIG_IsOK(res1)) {
21417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21418 }
21419 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21420 ecode2 = SWIG_AsVal_long(obj1, &val2);
21421 if (!SWIG_IsOK(ecode2)) {
21422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21423 }
21424 arg2 = static_cast< long >(val2);
21425 {
21426 PyThreadState* __tstate = wxPyBeginAllowThreads();
21427 (arg1)->SetStyle(arg2);
21428 wxPyEndAllowThreads(__tstate);
21429 if (PyErr_Occurred()) SWIG_fail;
21430 }
21431 resultobj = SWIG_Py_Void();
21432 return resultobj;
21433 fail:
21434 return NULL;
21435 }
21436
21437
21438 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21439 PyObject *resultobj = 0;
21440 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21441 long result;
21442 void *argp1 = 0 ;
21443 int res1 = 0 ;
21444 PyObject *swig_obj[1] ;
21445
21446 if (!args) SWIG_fail;
21447 swig_obj[0] = args;
21448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21449 if (!SWIG_IsOK(res1)) {
21450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21451 }
21452 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21453 {
21454 PyThreadState* __tstate = wxPyBeginAllowThreads();
21455 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21456 wxPyEndAllowThreads(__tstate);
21457 if (PyErr_Occurred()) SWIG_fail;
21458 }
21459 resultobj = SWIG_From_long(static_cast< long >(result));
21460 return resultobj;
21461 fail:
21462 return NULL;
21463 }
21464
21465
21466 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21467 PyObject *obj;
21468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21469 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21470 return SWIG_Py_Void();
21471 }
21472
21473 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21474 PyObject *resultobj = 0;
21475 wxString const &arg1_defvalue = wxPyEmptyString ;
21476 wxString *arg1 = (wxString *) &arg1_defvalue ;
21477 wxString const &arg2_defvalue = wxPyEmptyString ;
21478 wxString *arg2 = (wxString *) &arg2_defvalue ;
21479 wxString const &arg3_defvalue = wxPyEmptyString ;
21480 wxString *arg3 = (wxString *) &arg3_defvalue ;
21481 wxString const &arg4_defvalue = wxPyEmptyString ;
21482 wxString *arg4 = (wxString *) &arg4_defvalue ;
21483 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21484 wxConfig *result = 0 ;
21485 bool temp1 = false ;
21486 bool temp2 = false ;
21487 bool temp3 = false ;
21488 bool temp4 = false ;
21489 long val5 ;
21490 int ecode5 = 0 ;
21491 PyObject * obj0 = 0 ;
21492 PyObject * obj1 = 0 ;
21493 PyObject * obj2 = 0 ;
21494 PyObject * obj3 = 0 ;
21495 PyObject * obj4 = 0 ;
21496 char * kwnames[] = {
21497 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21498 };
21499
21500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21501 if (obj0) {
21502 {
21503 arg1 = wxString_in_helper(obj0);
21504 if (arg1 == NULL) SWIG_fail;
21505 temp1 = true;
21506 }
21507 }
21508 if (obj1) {
21509 {
21510 arg2 = wxString_in_helper(obj1);
21511 if (arg2 == NULL) SWIG_fail;
21512 temp2 = true;
21513 }
21514 }
21515 if (obj2) {
21516 {
21517 arg3 = wxString_in_helper(obj2);
21518 if (arg3 == NULL) SWIG_fail;
21519 temp3 = true;
21520 }
21521 }
21522 if (obj3) {
21523 {
21524 arg4 = wxString_in_helper(obj3);
21525 if (arg4 == NULL) SWIG_fail;
21526 temp4 = true;
21527 }
21528 }
21529 if (obj4) {
21530 ecode5 = SWIG_AsVal_long(obj4, &val5);
21531 if (!SWIG_IsOK(ecode5)) {
21532 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21533 }
21534 arg5 = static_cast< long >(val5);
21535 }
21536 {
21537 PyThreadState* __tstate = wxPyBeginAllowThreads();
21538 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21539 wxPyEndAllowThreads(__tstate);
21540 if (PyErr_Occurred()) SWIG_fail;
21541 }
21542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21543 {
21544 if (temp1)
21545 delete arg1;
21546 }
21547 {
21548 if (temp2)
21549 delete arg2;
21550 }
21551 {
21552 if (temp3)
21553 delete arg3;
21554 }
21555 {
21556 if (temp4)
21557 delete arg4;
21558 }
21559 return resultobj;
21560 fail:
21561 {
21562 if (temp1)
21563 delete arg1;
21564 }
21565 {
21566 if (temp2)
21567 delete arg2;
21568 }
21569 {
21570 if (temp3)
21571 delete arg3;
21572 }
21573 {
21574 if (temp4)
21575 delete arg4;
21576 }
21577 return NULL;
21578 }
21579
21580
21581 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21582 PyObject *resultobj = 0;
21583 wxConfig *arg1 = (wxConfig *) 0 ;
21584 void *argp1 = 0 ;
21585 int res1 = 0 ;
21586 PyObject *swig_obj[1] ;
21587
21588 if (!args) SWIG_fail;
21589 swig_obj[0] = args;
21590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21591 if (!SWIG_IsOK(res1)) {
21592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21593 }
21594 arg1 = reinterpret_cast< wxConfig * >(argp1);
21595 {
21596 PyThreadState* __tstate = wxPyBeginAllowThreads();
21597 delete arg1;
21598
21599 wxPyEndAllowThreads(__tstate);
21600 if (PyErr_Occurred()) SWIG_fail;
21601 }
21602 resultobj = SWIG_Py_Void();
21603 return resultobj;
21604 fail:
21605 return NULL;
21606 }
21607
21608
21609 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21610 PyObject *obj;
21611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21612 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21613 return SWIG_Py_Void();
21614 }
21615
21616 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21617 return SWIG_Python_InitShadowInstance(args);
21618 }
21619
21620 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21621 PyObject *resultobj = 0;
21622 wxString const &arg1_defvalue = wxPyEmptyString ;
21623 wxString *arg1 = (wxString *) &arg1_defvalue ;
21624 wxString const &arg2_defvalue = wxPyEmptyString ;
21625 wxString *arg2 = (wxString *) &arg2_defvalue ;
21626 wxString const &arg3_defvalue = wxPyEmptyString ;
21627 wxString *arg3 = (wxString *) &arg3_defvalue ;
21628 wxString const &arg4_defvalue = wxPyEmptyString ;
21629 wxString *arg4 = (wxString *) &arg4_defvalue ;
21630 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21631 wxFileConfig *result = 0 ;
21632 bool temp1 = false ;
21633 bool temp2 = false ;
21634 bool temp3 = false ;
21635 bool temp4 = false ;
21636 long val5 ;
21637 int ecode5 = 0 ;
21638 PyObject * obj0 = 0 ;
21639 PyObject * obj1 = 0 ;
21640 PyObject * obj2 = 0 ;
21641 PyObject * obj3 = 0 ;
21642 PyObject * obj4 = 0 ;
21643 char * kwnames[] = {
21644 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21645 };
21646
21647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21648 if (obj0) {
21649 {
21650 arg1 = wxString_in_helper(obj0);
21651 if (arg1 == NULL) SWIG_fail;
21652 temp1 = true;
21653 }
21654 }
21655 if (obj1) {
21656 {
21657 arg2 = wxString_in_helper(obj1);
21658 if (arg2 == NULL) SWIG_fail;
21659 temp2 = true;
21660 }
21661 }
21662 if (obj2) {
21663 {
21664 arg3 = wxString_in_helper(obj2);
21665 if (arg3 == NULL) SWIG_fail;
21666 temp3 = true;
21667 }
21668 }
21669 if (obj3) {
21670 {
21671 arg4 = wxString_in_helper(obj3);
21672 if (arg4 == NULL) SWIG_fail;
21673 temp4 = true;
21674 }
21675 }
21676 if (obj4) {
21677 ecode5 = SWIG_AsVal_long(obj4, &val5);
21678 if (!SWIG_IsOK(ecode5)) {
21679 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21680 }
21681 arg5 = static_cast< long >(val5);
21682 }
21683 {
21684 PyThreadState* __tstate = wxPyBeginAllowThreads();
21685 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21686 wxPyEndAllowThreads(__tstate);
21687 if (PyErr_Occurred()) SWIG_fail;
21688 }
21689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21690 {
21691 if (temp1)
21692 delete arg1;
21693 }
21694 {
21695 if (temp2)
21696 delete arg2;
21697 }
21698 {
21699 if (temp3)
21700 delete arg3;
21701 }
21702 {
21703 if (temp4)
21704 delete arg4;
21705 }
21706 return resultobj;
21707 fail:
21708 {
21709 if (temp1)
21710 delete arg1;
21711 }
21712 {
21713 if (temp2)
21714 delete arg2;
21715 }
21716 {
21717 if (temp3)
21718 delete arg3;
21719 }
21720 {
21721 if (temp4)
21722 delete arg4;
21723 }
21724 return NULL;
21725 }
21726
21727
21728 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21729 PyObject *resultobj = 0;
21730 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21731 void *argp1 = 0 ;
21732 int res1 = 0 ;
21733 PyObject *swig_obj[1] ;
21734
21735 if (!args) SWIG_fail;
21736 swig_obj[0] = args;
21737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21738 if (!SWIG_IsOK(res1)) {
21739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21740 }
21741 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21742 {
21743 PyThreadState* __tstate = wxPyBeginAllowThreads();
21744 delete arg1;
21745
21746 wxPyEndAllowThreads(__tstate);
21747 if (PyErr_Occurred()) SWIG_fail;
21748 }
21749 resultobj = SWIG_Py_Void();
21750 return resultobj;
21751 fail:
21752 return NULL;
21753 }
21754
21755
21756 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21757 PyObject *obj;
21758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21759 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21760 return SWIG_Py_Void();
21761 }
21762
21763 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21764 return SWIG_Python_InitShadowInstance(args);
21765 }
21766
21767 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21768 PyObject *resultobj = 0;
21769 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21770 wxString *arg2 = 0 ;
21771 wxConfigPathChanger *result = 0 ;
21772 void *argp1 = 0 ;
21773 int res1 = 0 ;
21774 bool temp2 = false ;
21775 PyObject * obj0 = 0 ;
21776 PyObject * obj1 = 0 ;
21777 char * kwnames[] = {
21778 (char *) "config",(char *) "entry", NULL
21779 };
21780
21781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21783 if (!SWIG_IsOK(res1)) {
21784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21785 }
21786 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21787 {
21788 arg2 = wxString_in_helper(obj1);
21789 if (arg2 == NULL) SWIG_fail;
21790 temp2 = true;
21791 }
21792 {
21793 PyThreadState* __tstate = wxPyBeginAllowThreads();
21794 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21795 wxPyEndAllowThreads(__tstate);
21796 if (PyErr_Occurred()) SWIG_fail;
21797 }
21798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21799 {
21800 if (temp2)
21801 delete arg2;
21802 }
21803 return resultobj;
21804 fail:
21805 {
21806 if (temp2)
21807 delete arg2;
21808 }
21809 return NULL;
21810 }
21811
21812
21813 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21814 PyObject *resultobj = 0;
21815 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21816 void *argp1 = 0 ;
21817 int res1 = 0 ;
21818 PyObject *swig_obj[1] ;
21819
21820 if (!args) SWIG_fail;
21821 swig_obj[0] = args;
21822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21823 if (!SWIG_IsOK(res1)) {
21824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21825 }
21826 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21827 {
21828 PyThreadState* __tstate = wxPyBeginAllowThreads();
21829 delete arg1;
21830
21831 wxPyEndAllowThreads(__tstate);
21832 if (PyErr_Occurred()) SWIG_fail;
21833 }
21834 resultobj = SWIG_Py_Void();
21835 return resultobj;
21836 fail:
21837 return NULL;
21838 }
21839
21840
21841 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21842 PyObject *resultobj = 0;
21843 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21844 wxString *result = 0 ;
21845 void *argp1 = 0 ;
21846 int res1 = 0 ;
21847 PyObject *swig_obj[1] ;
21848
21849 if (!args) SWIG_fail;
21850 swig_obj[0] = args;
21851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21852 if (!SWIG_IsOK(res1)) {
21853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21854 }
21855 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 {
21859 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21860 result = (wxString *) &_result_ref;
21861 }
21862 wxPyEndAllowThreads(__tstate);
21863 if (PyErr_Occurred()) SWIG_fail;
21864 }
21865 {
21866 #if wxUSE_UNICODE
21867 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21868 #else
21869 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21870 #endif
21871 }
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21879 PyObject *obj;
21880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21881 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21882 return SWIG_Py_Void();
21883 }
21884
21885 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21886 return SWIG_Python_InitShadowInstance(args);
21887 }
21888
21889 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21890 PyObject *resultobj = 0;
21891 wxString *arg1 = 0 ;
21892 wxString result;
21893 bool temp1 = false ;
21894 PyObject * obj0 = 0 ;
21895 char * kwnames[] = {
21896 (char *) "sz", NULL
21897 };
21898
21899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21900 {
21901 arg1 = wxString_in_helper(obj0);
21902 if (arg1 == NULL) SWIG_fail;
21903 temp1 = true;
21904 }
21905 {
21906 PyThreadState* __tstate = wxPyBeginAllowThreads();
21907 result = wxExpandEnvVars((wxString const &)*arg1);
21908 wxPyEndAllowThreads(__tstate);
21909 if (PyErr_Occurred()) SWIG_fail;
21910 }
21911 {
21912 #if wxUSE_UNICODE
21913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21914 #else
21915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21916 #endif
21917 }
21918 {
21919 if (temp1)
21920 delete arg1;
21921 }
21922 return resultobj;
21923 fail:
21924 {
21925 if (temp1)
21926 delete arg1;
21927 }
21928 return NULL;
21929 }
21930
21931
21932 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21933 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21934 return 1;
21935 }
21936
21937
21938 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21939 PyObject *pyobj = 0;
21940
21941 {
21942 #if wxUSE_UNICODE
21943 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21944 #else
21945 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21946 #endif
21947 }
21948 return pyobj;
21949 }
21950
21951
21952 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21953 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21954 return 1;
21955 }
21956
21957
21958 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21959 PyObject *pyobj = 0;
21960
21961 {
21962 #if wxUSE_UNICODE
21963 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21964 #else
21965 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21966 #endif
21967 }
21968 return pyobj;
21969 }
21970
21971
21972 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21973 PyObject *resultobj = 0;
21974 wxDateTime::Country arg1 ;
21975 int val1 ;
21976 int ecode1 = 0 ;
21977 PyObject * obj0 = 0 ;
21978 char * kwnames[] = {
21979 (char *) "country", NULL
21980 };
21981
21982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21983 ecode1 = SWIG_AsVal_int(obj0, &val1);
21984 if (!SWIG_IsOK(ecode1)) {
21985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21986 }
21987 arg1 = static_cast< wxDateTime::Country >(val1);
21988 {
21989 PyThreadState* __tstate = wxPyBeginAllowThreads();
21990 wxDateTime::SetCountry(arg1);
21991 wxPyEndAllowThreads(__tstate);
21992 if (PyErr_Occurred()) SWIG_fail;
21993 }
21994 resultobj = SWIG_Py_Void();
21995 return resultobj;
21996 fail:
21997 return NULL;
21998 }
21999
22000
22001 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22002 PyObject *resultobj = 0;
22003 wxDateTime::Country result;
22004
22005 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
22006 {
22007 PyThreadState* __tstate = wxPyBeginAllowThreads();
22008 result = (wxDateTime::Country)wxDateTime::GetCountry();
22009 wxPyEndAllowThreads(__tstate);
22010 if (PyErr_Occurred()) SWIG_fail;
22011 }
22012 resultobj = SWIG_From_int(static_cast< int >(result));
22013 return resultobj;
22014 fail:
22015 return NULL;
22016 }
22017
22018
22019 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22020 PyObject *resultobj = 0;
22021 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22022 bool result;
22023 int val1 ;
22024 int ecode1 = 0 ;
22025 PyObject * obj0 = 0 ;
22026 char * kwnames[] = {
22027 (char *) "country", NULL
22028 };
22029
22030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
22031 if (obj0) {
22032 ecode1 = SWIG_AsVal_int(obj0, &val1);
22033 if (!SWIG_IsOK(ecode1)) {
22034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22035 }
22036 arg1 = static_cast< wxDateTime::Country >(val1);
22037 }
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 {
22045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22046 }
22047 return resultobj;
22048 fail:
22049 return NULL;
22050 }
22051
22052
22053 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22054 PyObject *resultobj = 0;
22055 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22056 int result;
22057 int val1 ;
22058 int ecode1 = 0 ;
22059 PyObject * obj0 = 0 ;
22060 char * kwnames[] = {
22061 (char *) "cal", NULL
22062 };
22063
22064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
22065 if (obj0) {
22066 ecode1 = SWIG_AsVal_int(obj0, &val1);
22067 if (!SWIG_IsOK(ecode1)) {
22068 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22069 }
22070 arg1 = static_cast< wxDateTime::Calendar >(val1);
22071 }
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (int)wxDateTime::GetCurrentYear(arg1);
22075 wxPyEndAllowThreads(__tstate);
22076 if (PyErr_Occurred()) SWIG_fail;
22077 }
22078 resultobj = SWIG_From_int(static_cast< int >(result));
22079 return resultobj;
22080 fail:
22081 return NULL;
22082 }
22083
22084
22085 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22086 PyObject *resultobj = 0;
22087 int arg1 ;
22088 int result;
22089 int val1 ;
22090 int ecode1 = 0 ;
22091 PyObject * obj0 = 0 ;
22092 char * kwnames[] = {
22093 (char *) "year", NULL
22094 };
22095
22096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
22097 ecode1 = SWIG_AsVal_int(obj0, &val1);
22098 if (!SWIG_IsOK(ecode1)) {
22099 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
22100 }
22101 arg1 = static_cast< int >(val1);
22102 {
22103 PyThreadState* __tstate = wxPyBeginAllowThreads();
22104 result = (int)wxDateTime::ConvertYearToBC(arg1);
22105 wxPyEndAllowThreads(__tstate);
22106 if (PyErr_Occurred()) SWIG_fail;
22107 }
22108 resultobj = SWIG_From_int(static_cast< int >(result));
22109 return resultobj;
22110 fail:
22111 return NULL;
22112 }
22113
22114
22115 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22116 PyObject *resultobj = 0;
22117 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22118 wxDateTime::Month result;
22119 int val1 ;
22120 int ecode1 = 0 ;
22121 PyObject * obj0 = 0 ;
22122 char * kwnames[] = {
22123 (char *) "cal", NULL
22124 };
22125
22126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22127 if (obj0) {
22128 ecode1 = SWIG_AsVal_int(obj0, &val1);
22129 if (!SWIG_IsOK(ecode1)) {
22130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22131 }
22132 arg1 = static_cast< wxDateTime::Calendar >(val1);
22133 }
22134 {
22135 PyThreadState* __tstate = wxPyBeginAllowThreads();
22136 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22137 wxPyEndAllowThreads(__tstate);
22138 if (PyErr_Occurred()) SWIG_fail;
22139 }
22140 resultobj = SWIG_From_int(static_cast< int >(result));
22141 return resultobj;
22142 fail:
22143 return NULL;
22144 }
22145
22146
22147 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22148 PyObject *resultobj = 0;
22149 int arg1 = (int) wxDateTime::Inv_Year ;
22150 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22151 bool result;
22152 int val1 ;
22153 int ecode1 = 0 ;
22154 int val2 ;
22155 int ecode2 = 0 ;
22156 PyObject * obj0 = 0 ;
22157 PyObject * obj1 = 0 ;
22158 char * kwnames[] = {
22159 (char *) "year",(char *) "cal", NULL
22160 };
22161
22162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22163 if (obj0) {
22164 ecode1 = SWIG_AsVal_int(obj0, &val1);
22165 if (!SWIG_IsOK(ecode1)) {
22166 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22167 }
22168 arg1 = static_cast< int >(val1);
22169 }
22170 if (obj1) {
22171 ecode2 = SWIG_AsVal_int(obj1, &val2);
22172 if (!SWIG_IsOK(ecode2)) {
22173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22174 }
22175 arg2 = static_cast< wxDateTime::Calendar >(val2);
22176 }
22177 {
22178 PyThreadState* __tstate = wxPyBeginAllowThreads();
22179 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22180 wxPyEndAllowThreads(__tstate);
22181 if (PyErr_Occurred()) SWIG_fail;
22182 }
22183 {
22184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22185 }
22186 return resultobj;
22187 fail:
22188 return NULL;
22189 }
22190
22191
22192 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22193 PyObject *resultobj = 0;
22194 int arg1 = (int) wxDateTime::Inv_Year ;
22195 int result;
22196 int val1 ;
22197 int ecode1 = 0 ;
22198 PyObject * obj0 = 0 ;
22199 char * kwnames[] = {
22200 (char *) "year", NULL
22201 };
22202
22203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22204 if (obj0) {
22205 ecode1 = SWIG_AsVal_int(obj0, &val1);
22206 if (!SWIG_IsOK(ecode1)) {
22207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22208 }
22209 arg1 = static_cast< int >(val1);
22210 }
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 result = (int)wxDateTime::GetCentury(arg1);
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 resultobj = SWIG_From_int(static_cast< int >(result));
22218 return resultobj;
22219 fail:
22220 return NULL;
22221 }
22222
22223
22224 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22225 PyObject *resultobj = 0;
22226 int arg1 ;
22227 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22228 int result;
22229 int val1 ;
22230 int ecode1 = 0 ;
22231 int val2 ;
22232 int ecode2 = 0 ;
22233 PyObject * obj0 = 0 ;
22234 PyObject * obj1 = 0 ;
22235 char * kwnames[] = {
22236 (char *) "year",(char *) "cal", NULL
22237 };
22238
22239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22240 ecode1 = SWIG_AsVal_int(obj0, &val1);
22241 if (!SWIG_IsOK(ecode1)) {
22242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22243 }
22244 arg1 = static_cast< int >(val1);
22245 if (obj1) {
22246 ecode2 = SWIG_AsVal_int(obj1, &val2);
22247 if (!SWIG_IsOK(ecode2)) {
22248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22249 }
22250 arg2 = static_cast< wxDateTime::Calendar >(val2);
22251 }
22252 {
22253 PyThreadState* __tstate = wxPyBeginAllowThreads();
22254 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22255 wxPyEndAllowThreads(__tstate);
22256 if (PyErr_Occurred()) SWIG_fail;
22257 }
22258 resultobj = SWIG_From_int(static_cast< int >(result));
22259 return resultobj;
22260 fail:
22261 return NULL;
22262 }
22263
22264
22265 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22266 PyObject *resultobj = 0;
22267 wxDateTime::Month arg1 ;
22268 int arg2 = (int) wxDateTime::Inv_Year ;
22269 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22270 int result;
22271 int val1 ;
22272 int ecode1 = 0 ;
22273 int val2 ;
22274 int ecode2 = 0 ;
22275 int val3 ;
22276 int ecode3 = 0 ;
22277 PyObject * obj0 = 0 ;
22278 PyObject * obj1 = 0 ;
22279 PyObject * obj2 = 0 ;
22280 char * kwnames[] = {
22281 (char *) "month",(char *) "year",(char *) "cal", NULL
22282 };
22283
22284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22285 ecode1 = SWIG_AsVal_int(obj0, &val1);
22286 if (!SWIG_IsOK(ecode1)) {
22287 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22288 }
22289 arg1 = static_cast< wxDateTime::Month >(val1);
22290 if (obj1) {
22291 ecode2 = SWIG_AsVal_int(obj1, &val2);
22292 if (!SWIG_IsOK(ecode2)) {
22293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22294 }
22295 arg2 = static_cast< int >(val2);
22296 }
22297 if (obj2) {
22298 ecode3 = SWIG_AsVal_int(obj2, &val3);
22299 if (!SWIG_IsOK(ecode3)) {
22300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22301 }
22302 arg3 = static_cast< wxDateTime::Calendar >(val3);
22303 }
22304 {
22305 PyThreadState* __tstate = wxPyBeginAllowThreads();
22306 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22307 wxPyEndAllowThreads(__tstate);
22308 if (PyErr_Occurred()) SWIG_fail;
22309 }
22310 resultobj = SWIG_From_int(static_cast< int >(result));
22311 return resultobj;
22312 fail:
22313 return NULL;
22314 }
22315
22316
22317 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22318 PyObject *resultobj = 0;
22319 wxDateTime::Month arg1 ;
22320 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22321 wxString result;
22322 int val1 ;
22323 int ecode1 = 0 ;
22324 int val2 ;
22325 int ecode2 = 0 ;
22326 PyObject * obj0 = 0 ;
22327 PyObject * obj1 = 0 ;
22328 char * kwnames[] = {
22329 (char *) "month",(char *) "flags", NULL
22330 };
22331
22332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22333 ecode1 = SWIG_AsVal_int(obj0, &val1);
22334 if (!SWIG_IsOK(ecode1)) {
22335 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22336 }
22337 arg1 = static_cast< wxDateTime::Month >(val1);
22338 if (obj1) {
22339 ecode2 = SWIG_AsVal_int(obj1, &val2);
22340 if (!SWIG_IsOK(ecode2)) {
22341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22342 }
22343 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22344 }
22345 {
22346 PyThreadState* __tstate = wxPyBeginAllowThreads();
22347 result = wxDateTime::GetMonthName(arg1,arg2);
22348 wxPyEndAllowThreads(__tstate);
22349 if (PyErr_Occurred()) SWIG_fail;
22350 }
22351 {
22352 #if wxUSE_UNICODE
22353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22354 #else
22355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22356 #endif
22357 }
22358 return resultobj;
22359 fail:
22360 return NULL;
22361 }
22362
22363
22364 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22365 PyObject *resultobj = 0;
22366 wxDateTime::WeekDay arg1 ;
22367 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22368 wxString result;
22369 int val1 ;
22370 int ecode1 = 0 ;
22371 int val2 ;
22372 int ecode2 = 0 ;
22373 PyObject * obj0 = 0 ;
22374 PyObject * obj1 = 0 ;
22375 char * kwnames[] = {
22376 (char *) "weekday",(char *) "flags", NULL
22377 };
22378
22379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22380 ecode1 = SWIG_AsVal_int(obj0, &val1);
22381 if (!SWIG_IsOK(ecode1)) {
22382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22383 }
22384 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22385 if (obj1) {
22386 ecode2 = SWIG_AsVal_int(obj1, &val2);
22387 if (!SWIG_IsOK(ecode2)) {
22388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22389 }
22390 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22391 }
22392 {
22393 PyThreadState* __tstate = wxPyBeginAllowThreads();
22394 result = wxDateTime::GetWeekDayName(arg1,arg2);
22395 wxPyEndAllowThreads(__tstate);
22396 if (PyErr_Occurred()) SWIG_fail;
22397 }
22398 {
22399 #if wxUSE_UNICODE
22400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22401 #else
22402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22403 #endif
22404 }
22405 return resultobj;
22406 fail:
22407 return NULL;
22408 }
22409
22410
22411 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22412 PyObject *resultobj = 0;
22413 PyObject *result = 0 ;
22414
22415 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22416 {
22417 PyThreadState* __tstate = wxPyBeginAllowThreads();
22418 result = (PyObject *)wxDateTime_GetAmPmStrings();
22419 wxPyEndAllowThreads(__tstate);
22420 if (PyErr_Occurred()) SWIG_fail;
22421 }
22422 resultobj = result;
22423 return resultobj;
22424 fail:
22425 return NULL;
22426 }
22427
22428
22429 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22430 PyObject *resultobj = 0;
22431 int arg1 = (int) wxDateTime::Inv_Year ;
22432 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22433 bool result;
22434 int val1 ;
22435 int ecode1 = 0 ;
22436 int val2 ;
22437 int ecode2 = 0 ;
22438 PyObject * obj0 = 0 ;
22439 PyObject * obj1 = 0 ;
22440 char * kwnames[] = {
22441 (char *) "year",(char *) "country", NULL
22442 };
22443
22444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22445 if (obj0) {
22446 ecode1 = SWIG_AsVal_int(obj0, &val1);
22447 if (!SWIG_IsOK(ecode1)) {
22448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22449 }
22450 arg1 = static_cast< int >(val1);
22451 }
22452 if (obj1) {
22453 ecode2 = SWIG_AsVal_int(obj1, &val2);
22454 if (!SWIG_IsOK(ecode2)) {
22455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22456 }
22457 arg2 = static_cast< wxDateTime::Country >(val2);
22458 }
22459 {
22460 PyThreadState* __tstate = wxPyBeginAllowThreads();
22461 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22462 wxPyEndAllowThreads(__tstate);
22463 if (PyErr_Occurred()) SWIG_fail;
22464 }
22465 {
22466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22467 }
22468 return resultobj;
22469 fail:
22470 return NULL;
22471 }
22472
22473
22474 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22475 PyObject *resultobj = 0;
22476 int arg1 = (int) wxDateTime::Inv_Year ;
22477 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22478 wxDateTime result;
22479 int val1 ;
22480 int ecode1 = 0 ;
22481 int val2 ;
22482 int ecode2 = 0 ;
22483 PyObject * obj0 = 0 ;
22484 PyObject * obj1 = 0 ;
22485 char * kwnames[] = {
22486 (char *) "year",(char *) "country", NULL
22487 };
22488
22489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22490 if (obj0) {
22491 ecode1 = SWIG_AsVal_int(obj0, &val1);
22492 if (!SWIG_IsOK(ecode1)) {
22493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22494 }
22495 arg1 = static_cast< int >(val1);
22496 }
22497 if (obj1) {
22498 ecode2 = SWIG_AsVal_int(obj1, &val2);
22499 if (!SWIG_IsOK(ecode2)) {
22500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22501 }
22502 arg2 = static_cast< wxDateTime::Country >(val2);
22503 }
22504 {
22505 PyThreadState* __tstate = wxPyBeginAllowThreads();
22506 result = wxDateTime::GetBeginDST(arg1,arg2);
22507 wxPyEndAllowThreads(__tstate);
22508 if (PyErr_Occurred()) SWIG_fail;
22509 }
22510 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22511 return resultobj;
22512 fail:
22513 return NULL;
22514 }
22515
22516
22517 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22518 PyObject *resultobj = 0;
22519 int arg1 = (int) wxDateTime::Inv_Year ;
22520 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22521 wxDateTime result;
22522 int val1 ;
22523 int ecode1 = 0 ;
22524 int val2 ;
22525 int ecode2 = 0 ;
22526 PyObject * obj0 = 0 ;
22527 PyObject * obj1 = 0 ;
22528 char * kwnames[] = {
22529 (char *) "year",(char *) "country", NULL
22530 };
22531
22532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22533 if (obj0) {
22534 ecode1 = SWIG_AsVal_int(obj0, &val1);
22535 if (!SWIG_IsOK(ecode1)) {
22536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22537 }
22538 arg1 = static_cast< int >(val1);
22539 }
22540 if (obj1) {
22541 ecode2 = SWIG_AsVal_int(obj1, &val2);
22542 if (!SWIG_IsOK(ecode2)) {
22543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22544 }
22545 arg2 = static_cast< wxDateTime::Country >(val2);
22546 }
22547 {
22548 PyThreadState* __tstate = wxPyBeginAllowThreads();
22549 result = wxDateTime::GetEndDST(arg1,arg2);
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22554 return resultobj;
22555 fail:
22556 return NULL;
22557 }
22558
22559
22560 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22561 PyObject *resultobj = 0;
22562 wxDateTime result;
22563
22564 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22565 {
22566 PyThreadState* __tstate = wxPyBeginAllowThreads();
22567 result = wxDateTime::Now();
22568 wxPyEndAllowThreads(__tstate);
22569 if (PyErr_Occurred()) SWIG_fail;
22570 }
22571 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22572 return resultobj;
22573 fail:
22574 return NULL;
22575 }
22576
22577
22578 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22579 PyObject *resultobj = 0;
22580 wxDateTime result;
22581
22582 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22583 {
22584 PyThreadState* __tstate = wxPyBeginAllowThreads();
22585 result = wxDateTime::UNow();
22586 wxPyEndAllowThreads(__tstate);
22587 if (PyErr_Occurred()) SWIG_fail;
22588 }
22589 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22590 return resultobj;
22591 fail:
22592 return NULL;
22593 }
22594
22595
22596 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22597 PyObject *resultobj = 0;
22598 wxDateTime result;
22599
22600 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22601 {
22602 PyThreadState* __tstate = wxPyBeginAllowThreads();
22603 result = wxDateTime::Today();
22604 wxPyEndAllowThreads(__tstate);
22605 if (PyErr_Occurred()) SWIG_fail;
22606 }
22607 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22608 return resultobj;
22609 fail:
22610 return NULL;
22611 }
22612
22613
22614 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22615 PyObject *resultobj = 0;
22616 wxDateTime *result = 0 ;
22617
22618 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22619 {
22620 PyThreadState* __tstate = wxPyBeginAllowThreads();
22621 result = (wxDateTime *)new wxDateTime();
22622 wxPyEndAllowThreads(__tstate);
22623 if (PyErr_Occurred()) SWIG_fail;
22624 }
22625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22626 return resultobj;
22627 fail:
22628 return NULL;
22629 }
22630
22631
22632 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22633 PyObject *resultobj = 0;
22634 time_t arg1 ;
22635 wxDateTime *result = 0 ;
22636 unsigned int val1 ;
22637 int ecode1 = 0 ;
22638 PyObject * obj0 = 0 ;
22639 char * kwnames[] = {
22640 (char *) "timet", NULL
22641 };
22642
22643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22644 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22645 if (!SWIG_IsOK(ecode1)) {
22646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22647 }
22648 arg1 = static_cast< time_t >(val1);
22649 {
22650 PyThreadState* __tstate = wxPyBeginAllowThreads();
22651 result = (wxDateTime *)new wxDateTime(arg1);
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22663 PyObject *resultobj = 0;
22664 double arg1 ;
22665 wxDateTime *result = 0 ;
22666 double val1 ;
22667 int ecode1 = 0 ;
22668 PyObject * obj0 = 0 ;
22669 char * kwnames[] = {
22670 (char *) "jdn", NULL
22671 };
22672
22673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22674 ecode1 = SWIG_AsVal_double(obj0, &val1);
22675 if (!SWIG_IsOK(ecode1)) {
22676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22677 }
22678 arg1 = static_cast< double >(val1);
22679 {
22680 PyThreadState* __tstate = wxPyBeginAllowThreads();
22681 result = (wxDateTime *)new wxDateTime(arg1);
22682 wxPyEndAllowThreads(__tstate);
22683 if (PyErr_Occurred()) SWIG_fail;
22684 }
22685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22686 return resultobj;
22687 fail:
22688 return NULL;
22689 }
22690
22691
22692 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22693 PyObject *resultobj = 0;
22694 int arg1 ;
22695 int arg2 = (int) 0 ;
22696 int arg3 = (int) 0 ;
22697 int arg4 = (int) 0 ;
22698 wxDateTime *result = 0 ;
22699 int val1 ;
22700 int ecode1 = 0 ;
22701 int val2 ;
22702 int ecode2 = 0 ;
22703 int val3 ;
22704 int ecode3 = 0 ;
22705 int val4 ;
22706 int ecode4 = 0 ;
22707 PyObject * obj0 = 0 ;
22708 PyObject * obj1 = 0 ;
22709 PyObject * obj2 = 0 ;
22710 PyObject * obj3 = 0 ;
22711 char * kwnames[] = {
22712 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22713 };
22714
22715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22716 ecode1 = SWIG_AsVal_int(obj0, &val1);
22717 if (!SWIG_IsOK(ecode1)) {
22718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22719 }
22720 arg1 = static_cast< int >(val1);
22721 if (obj1) {
22722 ecode2 = SWIG_AsVal_int(obj1, &val2);
22723 if (!SWIG_IsOK(ecode2)) {
22724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22725 }
22726 arg2 = static_cast< int >(val2);
22727 }
22728 if (obj2) {
22729 ecode3 = SWIG_AsVal_int(obj2, &val3);
22730 if (!SWIG_IsOK(ecode3)) {
22731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22732 }
22733 arg3 = static_cast< int >(val3);
22734 }
22735 if (obj3) {
22736 ecode4 = SWIG_AsVal_int(obj3, &val4);
22737 if (!SWIG_IsOK(ecode4)) {
22738 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22739 }
22740 arg4 = static_cast< int >(val4);
22741 }
22742 {
22743 PyThreadState* __tstate = wxPyBeginAllowThreads();
22744 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22745 wxPyEndAllowThreads(__tstate);
22746 if (PyErr_Occurred()) SWIG_fail;
22747 }
22748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22749 return resultobj;
22750 fail:
22751 return NULL;
22752 }
22753
22754
22755 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22756 PyObject *resultobj = 0;
22757 int arg1 ;
22758 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22759 int arg3 = (int) wxDateTime::Inv_Year ;
22760 int arg4 = (int) 0 ;
22761 int arg5 = (int) 0 ;
22762 int arg6 = (int) 0 ;
22763 int arg7 = (int) 0 ;
22764 wxDateTime *result = 0 ;
22765 int val1 ;
22766 int ecode1 = 0 ;
22767 int val2 ;
22768 int ecode2 = 0 ;
22769 int val3 ;
22770 int ecode3 = 0 ;
22771 int val4 ;
22772 int ecode4 = 0 ;
22773 int val5 ;
22774 int ecode5 = 0 ;
22775 int val6 ;
22776 int ecode6 = 0 ;
22777 int val7 ;
22778 int ecode7 = 0 ;
22779 PyObject * obj0 = 0 ;
22780 PyObject * obj1 = 0 ;
22781 PyObject * obj2 = 0 ;
22782 PyObject * obj3 = 0 ;
22783 PyObject * obj4 = 0 ;
22784 PyObject * obj5 = 0 ;
22785 PyObject * obj6 = 0 ;
22786 char * kwnames[] = {
22787 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22788 };
22789
22790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22791 ecode1 = SWIG_AsVal_int(obj0, &val1);
22792 if (!SWIG_IsOK(ecode1)) {
22793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22794 }
22795 arg1 = static_cast< int >(val1);
22796 if (obj1) {
22797 ecode2 = SWIG_AsVal_int(obj1, &val2);
22798 if (!SWIG_IsOK(ecode2)) {
22799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22800 }
22801 arg2 = static_cast< wxDateTime::Month >(val2);
22802 }
22803 if (obj2) {
22804 ecode3 = SWIG_AsVal_int(obj2, &val3);
22805 if (!SWIG_IsOK(ecode3)) {
22806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22807 }
22808 arg3 = static_cast< int >(val3);
22809 }
22810 if (obj3) {
22811 ecode4 = SWIG_AsVal_int(obj3, &val4);
22812 if (!SWIG_IsOK(ecode4)) {
22813 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22814 }
22815 arg4 = static_cast< int >(val4);
22816 }
22817 if (obj4) {
22818 ecode5 = SWIG_AsVal_int(obj4, &val5);
22819 if (!SWIG_IsOK(ecode5)) {
22820 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22821 }
22822 arg5 = static_cast< int >(val5);
22823 }
22824 if (obj5) {
22825 ecode6 = SWIG_AsVal_int(obj5, &val6);
22826 if (!SWIG_IsOK(ecode6)) {
22827 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22828 }
22829 arg6 = static_cast< int >(val6);
22830 }
22831 if (obj6) {
22832 ecode7 = SWIG_AsVal_int(obj6, &val7);
22833 if (!SWIG_IsOK(ecode7)) {
22834 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22835 }
22836 arg7 = static_cast< int >(val7);
22837 }
22838 {
22839 PyThreadState* __tstate = wxPyBeginAllowThreads();
22840 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22841 wxPyEndAllowThreads(__tstate);
22842 if (PyErr_Occurred()) SWIG_fail;
22843 }
22844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22845 return resultobj;
22846 fail:
22847 return NULL;
22848 }
22849
22850
22851 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22852 PyObject *resultobj = 0;
22853 wxDateTime *arg1 = 0 ;
22854 wxDateTime *result = 0 ;
22855 void *argp1 = 0 ;
22856 int res1 = 0 ;
22857 PyObject * obj0 = 0 ;
22858 char * kwnames[] = {
22859 (char *) "date", NULL
22860 };
22861
22862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22863 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22864 if (!SWIG_IsOK(res1)) {
22865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22866 }
22867 if (!argp1) {
22868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22869 }
22870 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22871 {
22872 PyThreadState* __tstate = wxPyBeginAllowThreads();
22873 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22874 wxPyEndAllowThreads(__tstate);
22875 if (PyErr_Occurred()) SWIG_fail;
22876 }
22877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22878 return resultobj;
22879 fail:
22880 return NULL;
22881 }
22882
22883
22884 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22885 PyObject *resultobj = 0;
22886 wxDateTime *arg1 = (wxDateTime *) 0 ;
22887 void *argp1 = 0 ;
22888 int res1 = 0 ;
22889 PyObject *swig_obj[1] ;
22890
22891 if (!args) SWIG_fail;
22892 swig_obj[0] = args;
22893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22894 if (!SWIG_IsOK(res1)) {
22895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22896 }
22897 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22898 {
22899 PyThreadState* __tstate = wxPyBeginAllowThreads();
22900 delete arg1;
22901
22902 wxPyEndAllowThreads(__tstate);
22903 if (PyErr_Occurred()) SWIG_fail;
22904 }
22905 resultobj = SWIG_Py_Void();
22906 return resultobj;
22907 fail:
22908 return NULL;
22909 }
22910
22911
22912 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22913 PyObject *resultobj = 0;
22914 wxDateTime *arg1 = (wxDateTime *) 0 ;
22915 wxDateTime *result = 0 ;
22916 void *argp1 = 0 ;
22917 int res1 = 0 ;
22918 PyObject *swig_obj[1] ;
22919
22920 if (!args) SWIG_fail;
22921 swig_obj[0] = args;
22922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22923 if (!SWIG_IsOK(res1)) {
22924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22925 }
22926 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22927 {
22928 PyThreadState* __tstate = wxPyBeginAllowThreads();
22929 {
22930 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22931 result = (wxDateTime *) &_result_ref;
22932 }
22933 wxPyEndAllowThreads(__tstate);
22934 if (PyErr_Occurred()) SWIG_fail;
22935 }
22936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22937 return resultobj;
22938 fail:
22939 return NULL;
22940 }
22941
22942
22943 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22944 PyObject *resultobj = 0;
22945 wxDateTime *arg1 = (wxDateTime *) 0 ;
22946 time_t arg2 ;
22947 wxDateTime *result = 0 ;
22948 void *argp1 = 0 ;
22949 int res1 = 0 ;
22950 unsigned int val2 ;
22951 int ecode2 = 0 ;
22952 PyObject * obj0 = 0 ;
22953 PyObject * obj1 = 0 ;
22954 char * kwnames[] = {
22955 (char *) "self",(char *) "timet", NULL
22956 };
22957
22958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22960 if (!SWIG_IsOK(res1)) {
22961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22962 }
22963 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22964 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22965 if (!SWIG_IsOK(ecode2)) {
22966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22967 }
22968 arg2 = static_cast< time_t >(val2);
22969 {
22970 PyThreadState* __tstate = wxPyBeginAllowThreads();
22971 {
22972 wxDateTime &_result_ref = (arg1)->Set(arg2);
22973 result = (wxDateTime *) &_result_ref;
22974 }
22975 wxPyEndAllowThreads(__tstate);
22976 if (PyErr_Occurred()) SWIG_fail;
22977 }
22978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22979 return resultobj;
22980 fail:
22981 return NULL;
22982 }
22983
22984
22985 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22986 PyObject *resultobj = 0;
22987 wxDateTime *arg1 = (wxDateTime *) 0 ;
22988 double arg2 ;
22989 wxDateTime *result = 0 ;
22990 void *argp1 = 0 ;
22991 int res1 = 0 ;
22992 double val2 ;
22993 int ecode2 = 0 ;
22994 PyObject * obj0 = 0 ;
22995 PyObject * obj1 = 0 ;
22996 char * kwnames[] = {
22997 (char *) "self",(char *) "jdn", NULL
22998 };
22999
23000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
23001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23002 if (!SWIG_IsOK(res1)) {
23003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
23004 }
23005 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23006 ecode2 = SWIG_AsVal_double(obj1, &val2);
23007 if (!SWIG_IsOK(ecode2)) {
23008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23009 }
23010 arg2 = static_cast< double >(val2);
23011 {
23012 PyThreadState* __tstate = wxPyBeginAllowThreads();
23013 {
23014 wxDateTime &_result_ref = (arg1)->Set(arg2);
23015 result = (wxDateTime *) &_result_ref;
23016 }
23017 wxPyEndAllowThreads(__tstate);
23018 if (PyErr_Occurred()) SWIG_fail;
23019 }
23020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23021 return resultobj;
23022 fail:
23023 return NULL;
23024 }
23025
23026
23027 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23028 PyObject *resultobj = 0;
23029 wxDateTime *arg1 = (wxDateTime *) 0 ;
23030 int arg2 ;
23031 int arg3 = (int) 0 ;
23032 int arg4 = (int) 0 ;
23033 int arg5 = (int) 0 ;
23034 wxDateTime *result = 0 ;
23035 void *argp1 = 0 ;
23036 int res1 = 0 ;
23037 int val2 ;
23038 int ecode2 = 0 ;
23039 int val3 ;
23040 int ecode3 = 0 ;
23041 int val4 ;
23042 int ecode4 = 0 ;
23043 int val5 ;
23044 int ecode5 = 0 ;
23045 PyObject * obj0 = 0 ;
23046 PyObject * obj1 = 0 ;
23047 PyObject * obj2 = 0 ;
23048 PyObject * obj3 = 0 ;
23049 PyObject * obj4 = 0 ;
23050 char * kwnames[] = {
23051 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23052 };
23053
23054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23056 if (!SWIG_IsOK(res1)) {
23057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
23058 }
23059 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23060 ecode2 = SWIG_AsVal_int(obj1, &val2);
23061 if (!SWIG_IsOK(ecode2)) {
23062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
23063 }
23064 arg2 = static_cast< int >(val2);
23065 if (obj2) {
23066 ecode3 = SWIG_AsVal_int(obj2, &val3);
23067 if (!SWIG_IsOK(ecode3)) {
23068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
23069 }
23070 arg3 = static_cast< int >(val3);
23071 }
23072 if (obj3) {
23073 ecode4 = SWIG_AsVal_int(obj3, &val4);
23074 if (!SWIG_IsOK(ecode4)) {
23075 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
23076 }
23077 arg4 = static_cast< int >(val4);
23078 }
23079 if (obj4) {
23080 ecode5 = SWIG_AsVal_int(obj4, &val5);
23081 if (!SWIG_IsOK(ecode5)) {
23082 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
23083 }
23084 arg5 = static_cast< int >(val5);
23085 }
23086 {
23087 PyThreadState* __tstate = wxPyBeginAllowThreads();
23088 {
23089 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
23090 result = (wxDateTime *) &_result_ref;
23091 }
23092 wxPyEndAllowThreads(__tstate);
23093 if (PyErr_Occurred()) SWIG_fail;
23094 }
23095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23096 return resultobj;
23097 fail:
23098 return NULL;
23099 }
23100
23101
23102 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23103 PyObject *resultobj = 0;
23104 wxDateTime *arg1 = (wxDateTime *) 0 ;
23105 int arg2 ;
23106 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23107 int arg4 = (int) wxDateTime::Inv_Year ;
23108 int arg5 = (int) 0 ;
23109 int arg6 = (int) 0 ;
23110 int arg7 = (int) 0 ;
23111 int arg8 = (int) 0 ;
23112 wxDateTime *result = 0 ;
23113 void *argp1 = 0 ;
23114 int res1 = 0 ;
23115 int val2 ;
23116 int ecode2 = 0 ;
23117 int val3 ;
23118 int ecode3 = 0 ;
23119 int val4 ;
23120 int ecode4 = 0 ;
23121 int val5 ;
23122 int ecode5 = 0 ;
23123 int val6 ;
23124 int ecode6 = 0 ;
23125 int val7 ;
23126 int ecode7 = 0 ;
23127 int val8 ;
23128 int ecode8 = 0 ;
23129 PyObject * obj0 = 0 ;
23130 PyObject * obj1 = 0 ;
23131 PyObject * obj2 = 0 ;
23132 PyObject * obj3 = 0 ;
23133 PyObject * obj4 = 0 ;
23134 PyObject * obj5 = 0 ;
23135 PyObject * obj6 = 0 ;
23136 PyObject * obj7 = 0 ;
23137 char * kwnames[] = {
23138 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23139 };
23140
23141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23143 if (!SWIG_IsOK(res1)) {
23144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23145 }
23146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23147 ecode2 = SWIG_AsVal_int(obj1, &val2);
23148 if (!SWIG_IsOK(ecode2)) {
23149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23150 }
23151 arg2 = static_cast< int >(val2);
23152 if (obj2) {
23153 ecode3 = SWIG_AsVal_int(obj2, &val3);
23154 if (!SWIG_IsOK(ecode3)) {
23155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23156 }
23157 arg3 = static_cast< wxDateTime::Month >(val3);
23158 }
23159 if (obj3) {
23160 ecode4 = SWIG_AsVal_int(obj3, &val4);
23161 if (!SWIG_IsOK(ecode4)) {
23162 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23163 }
23164 arg4 = static_cast< int >(val4);
23165 }
23166 if (obj4) {
23167 ecode5 = SWIG_AsVal_int(obj4, &val5);
23168 if (!SWIG_IsOK(ecode5)) {
23169 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23170 }
23171 arg5 = static_cast< int >(val5);
23172 }
23173 if (obj5) {
23174 ecode6 = SWIG_AsVal_int(obj5, &val6);
23175 if (!SWIG_IsOK(ecode6)) {
23176 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23177 }
23178 arg6 = static_cast< int >(val6);
23179 }
23180 if (obj6) {
23181 ecode7 = SWIG_AsVal_int(obj6, &val7);
23182 if (!SWIG_IsOK(ecode7)) {
23183 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23184 }
23185 arg7 = static_cast< int >(val7);
23186 }
23187 if (obj7) {
23188 ecode8 = SWIG_AsVal_int(obj7, &val8);
23189 if (!SWIG_IsOK(ecode8)) {
23190 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23191 }
23192 arg8 = static_cast< int >(val8);
23193 }
23194 {
23195 PyThreadState* __tstate = wxPyBeginAllowThreads();
23196 {
23197 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23198 result = (wxDateTime *) &_result_ref;
23199 }
23200 wxPyEndAllowThreads(__tstate);
23201 if (PyErr_Occurred()) SWIG_fail;
23202 }
23203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23211 PyObject *resultobj = 0;
23212 wxDateTime *arg1 = (wxDateTime *) 0 ;
23213 wxDateTime *result = 0 ;
23214 void *argp1 = 0 ;
23215 int res1 = 0 ;
23216 PyObject *swig_obj[1] ;
23217
23218 if (!args) SWIG_fail;
23219 swig_obj[0] = args;
23220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23221 if (!SWIG_IsOK(res1)) {
23222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23223 }
23224 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23225 {
23226 PyThreadState* __tstate = wxPyBeginAllowThreads();
23227 {
23228 wxDateTime &_result_ref = (arg1)->ResetTime();
23229 result = (wxDateTime *) &_result_ref;
23230 }
23231 wxPyEndAllowThreads(__tstate);
23232 if (PyErr_Occurred()) SWIG_fail;
23233 }
23234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23235 return resultobj;
23236 fail:
23237 return NULL;
23238 }
23239
23240
23241 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23242 PyObject *resultobj = 0;
23243 wxDateTime *arg1 = (wxDateTime *) 0 ;
23244 int arg2 ;
23245 wxDateTime *result = 0 ;
23246 void *argp1 = 0 ;
23247 int res1 = 0 ;
23248 int val2 ;
23249 int ecode2 = 0 ;
23250 PyObject * obj0 = 0 ;
23251 PyObject * obj1 = 0 ;
23252 char * kwnames[] = {
23253 (char *) "self",(char *) "year", NULL
23254 };
23255
23256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23258 if (!SWIG_IsOK(res1)) {
23259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23260 }
23261 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23262 ecode2 = SWIG_AsVal_int(obj1, &val2);
23263 if (!SWIG_IsOK(ecode2)) {
23264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23265 }
23266 arg2 = static_cast< int >(val2);
23267 {
23268 PyThreadState* __tstate = wxPyBeginAllowThreads();
23269 {
23270 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23271 result = (wxDateTime *) &_result_ref;
23272 }
23273 wxPyEndAllowThreads(__tstate);
23274 if (PyErr_Occurred()) SWIG_fail;
23275 }
23276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23284 PyObject *resultobj = 0;
23285 wxDateTime *arg1 = (wxDateTime *) 0 ;
23286 wxDateTime::Month arg2 ;
23287 wxDateTime *result = 0 ;
23288 void *argp1 = 0 ;
23289 int res1 = 0 ;
23290 int val2 ;
23291 int ecode2 = 0 ;
23292 PyObject * obj0 = 0 ;
23293 PyObject * obj1 = 0 ;
23294 char * kwnames[] = {
23295 (char *) "self",(char *) "month", NULL
23296 };
23297
23298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23300 if (!SWIG_IsOK(res1)) {
23301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23302 }
23303 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23304 ecode2 = SWIG_AsVal_int(obj1, &val2);
23305 if (!SWIG_IsOK(ecode2)) {
23306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23307 }
23308 arg2 = static_cast< wxDateTime::Month >(val2);
23309 {
23310 PyThreadState* __tstate = wxPyBeginAllowThreads();
23311 {
23312 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23313 result = (wxDateTime *) &_result_ref;
23314 }
23315 wxPyEndAllowThreads(__tstate);
23316 if (PyErr_Occurred()) SWIG_fail;
23317 }
23318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23319 return resultobj;
23320 fail:
23321 return NULL;
23322 }
23323
23324
23325 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23326 PyObject *resultobj = 0;
23327 wxDateTime *arg1 = (wxDateTime *) 0 ;
23328 int arg2 ;
23329 wxDateTime *result = 0 ;
23330 void *argp1 = 0 ;
23331 int res1 = 0 ;
23332 int val2 ;
23333 int ecode2 = 0 ;
23334 PyObject * obj0 = 0 ;
23335 PyObject * obj1 = 0 ;
23336 char * kwnames[] = {
23337 (char *) "self",(char *) "day", NULL
23338 };
23339
23340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23342 if (!SWIG_IsOK(res1)) {
23343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23344 }
23345 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23346 ecode2 = SWIG_AsVal_int(obj1, &val2);
23347 if (!SWIG_IsOK(ecode2)) {
23348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23349 }
23350 arg2 = static_cast< int >(val2);
23351 {
23352 PyThreadState* __tstate = wxPyBeginAllowThreads();
23353 {
23354 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23355 result = (wxDateTime *) &_result_ref;
23356 }
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23368 PyObject *resultobj = 0;
23369 wxDateTime *arg1 = (wxDateTime *) 0 ;
23370 int arg2 ;
23371 wxDateTime *result = 0 ;
23372 void *argp1 = 0 ;
23373 int res1 = 0 ;
23374 int val2 ;
23375 int ecode2 = 0 ;
23376 PyObject * obj0 = 0 ;
23377 PyObject * obj1 = 0 ;
23378 char * kwnames[] = {
23379 (char *) "self",(char *) "hour", NULL
23380 };
23381
23382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23384 if (!SWIG_IsOK(res1)) {
23385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23386 }
23387 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23388 ecode2 = SWIG_AsVal_int(obj1, &val2);
23389 if (!SWIG_IsOK(ecode2)) {
23390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23391 }
23392 arg2 = static_cast< int >(val2);
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 {
23396 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23397 result = (wxDateTime *) &_result_ref;
23398 }
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23403 return resultobj;
23404 fail:
23405 return NULL;
23406 }
23407
23408
23409 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23410 PyObject *resultobj = 0;
23411 wxDateTime *arg1 = (wxDateTime *) 0 ;
23412 int arg2 ;
23413 wxDateTime *result = 0 ;
23414 void *argp1 = 0 ;
23415 int res1 = 0 ;
23416 int val2 ;
23417 int ecode2 = 0 ;
23418 PyObject * obj0 = 0 ;
23419 PyObject * obj1 = 0 ;
23420 char * kwnames[] = {
23421 (char *) "self",(char *) "minute", NULL
23422 };
23423
23424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23426 if (!SWIG_IsOK(res1)) {
23427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23428 }
23429 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23430 ecode2 = SWIG_AsVal_int(obj1, &val2);
23431 if (!SWIG_IsOK(ecode2)) {
23432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23433 }
23434 arg2 = static_cast< int >(val2);
23435 {
23436 PyThreadState* __tstate = wxPyBeginAllowThreads();
23437 {
23438 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23439 result = (wxDateTime *) &_result_ref;
23440 }
23441 wxPyEndAllowThreads(__tstate);
23442 if (PyErr_Occurred()) SWIG_fail;
23443 }
23444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23445 return resultobj;
23446 fail:
23447 return NULL;
23448 }
23449
23450
23451 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23452 PyObject *resultobj = 0;
23453 wxDateTime *arg1 = (wxDateTime *) 0 ;
23454 int arg2 ;
23455 wxDateTime *result = 0 ;
23456 void *argp1 = 0 ;
23457 int res1 = 0 ;
23458 int val2 ;
23459 int ecode2 = 0 ;
23460 PyObject * obj0 = 0 ;
23461 PyObject * obj1 = 0 ;
23462 char * kwnames[] = {
23463 (char *) "self",(char *) "second", NULL
23464 };
23465
23466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23468 if (!SWIG_IsOK(res1)) {
23469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23470 }
23471 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23472 ecode2 = SWIG_AsVal_int(obj1, &val2);
23473 if (!SWIG_IsOK(ecode2)) {
23474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23475 }
23476 arg2 = static_cast< int >(val2);
23477 {
23478 PyThreadState* __tstate = wxPyBeginAllowThreads();
23479 {
23480 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23481 result = (wxDateTime *) &_result_ref;
23482 }
23483 wxPyEndAllowThreads(__tstate);
23484 if (PyErr_Occurred()) SWIG_fail;
23485 }
23486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23487 return resultobj;
23488 fail:
23489 return NULL;
23490 }
23491
23492
23493 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23494 PyObject *resultobj = 0;
23495 wxDateTime *arg1 = (wxDateTime *) 0 ;
23496 int arg2 ;
23497 wxDateTime *result = 0 ;
23498 void *argp1 = 0 ;
23499 int res1 = 0 ;
23500 int val2 ;
23501 int ecode2 = 0 ;
23502 PyObject * obj0 = 0 ;
23503 PyObject * obj1 = 0 ;
23504 char * kwnames[] = {
23505 (char *) "self",(char *) "millisecond", NULL
23506 };
23507
23508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23510 if (!SWIG_IsOK(res1)) {
23511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23512 }
23513 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23514 ecode2 = SWIG_AsVal_int(obj1, &val2);
23515 if (!SWIG_IsOK(ecode2)) {
23516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23517 }
23518 arg2 = static_cast< int >(val2);
23519 {
23520 PyThreadState* __tstate = wxPyBeginAllowThreads();
23521 {
23522 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23523 result = (wxDateTime *) &_result_ref;
23524 }
23525 wxPyEndAllowThreads(__tstate);
23526 if (PyErr_Occurred()) SWIG_fail;
23527 }
23528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23536 PyObject *resultobj = 0;
23537 wxDateTime *arg1 = (wxDateTime *) 0 ;
23538 wxDateTime::WeekDay arg2 ;
23539 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23540 wxDateTime *result = 0 ;
23541 void *argp1 = 0 ;
23542 int res1 = 0 ;
23543 int val2 ;
23544 int ecode2 = 0 ;
23545 int val3 ;
23546 int ecode3 = 0 ;
23547 PyObject * obj0 = 0 ;
23548 PyObject * obj1 = 0 ;
23549 PyObject * obj2 = 0 ;
23550 char * kwnames[] = {
23551 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23552 };
23553
23554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23556 if (!SWIG_IsOK(res1)) {
23557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23558 }
23559 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23560 ecode2 = SWIG_AsVal_int(obj1, &val2);
23561 if (!SWIG_IsOK(ecode2)) {
23562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23563 }
23564 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23565 if (obj2) {
23566 ecode3 = SWIG_AsVal_int(obj2, &val3);
23567 if (!SWIG_IsOK(ecode3)) {
23568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23569 }
23570 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23571 }
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 {
23575 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23576 result = (wxDateTime *) &_result_ref;
23577 }
23578 wxPyEndAllowThreads(__tstate);
23579 if (PyErr_Occurred()) SWIG_fail;
23580 }
23581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23582 return resultobj;
23583 fail:
23584 return NULL;
23585 }
23586
23587
23588 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23589 PyObject *resultobj = 0;
23590 wxDateTime *arg1 = (wxDateTime *) 0 ;
23591 wxDateTime::WeekDay arg2 ;
23592 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23593 wxDateTime result;
23594 void *argp1 = 0 ;
23595 int res1 = 0 ;
23596 int val2 ;
23597 int ecode2 = 0 ;
23598 int val3 ;
23599 int ecode3 = 0 ;
23600 PyObject * obj0 = 0 ;
23601 PyObject * obj1 = 0 ;
23602 PyObject * obj2 = 0 ;
23603 char * kwnames[] = {
23604 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23605 };
23606
23607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23609 if (!SWIG_IsOK(res1)) {
23610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23611 }
23612 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23613 ecode2 = SWIG_AsVal_int(obj1, &val2);
23614 if (!SWIG_IsOK(ecode2)) {
23615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23616 }
23617 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23618 if (obj2) {
23619 ecode3 = SWIG_AsVal_int(obj2, &val3);
23620 if (!SWIG_IsOK(ecode3)) {
23621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23622 }
23623 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23624 }
23625 {
23626 PyThreadState* __tstate = wxPyBeginAllowThreads();
23627 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23628 wxPyEndAllowThreads(__tstate);
23629 if (PyErr_Occurred()) SWIG_fail;
23630 }
23631 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23639 PyObject *resultobj = 0;
23640 wxDateTime *arg1 = (wxDateTime *) 0 ;
23641 wxDateTime::WeekDay arg2 ;
23642 wxDateTime *result = 0 ;
23643 void *argp1 = 0 ;
23644 int res1 = 0 ;
23645 int val2 ;
23646 int ecode2 = 0 ;
23647 PyObject * obj0 = 0 ;
23648 PyObject * obj1 = 0 ;
23649 char * kwnames[] = {
23650 (char *) "self",(char *) "weekday", NULL
23651 };
23652
23653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23655 if (!SWIG_IsOK(res1)) {
23656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23657 }
23658 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23659 ecode2 = SWIG_AsVal_int(obj1, &val2);
23660 if (!SWIG_IsOK(ecode2)) {
23661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23662 }
23663 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 {
23667 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23668 result = (wxDateTime *) &_result_ref;
23669 }
23670 wxPyEndAllowThreads(__tstate);
23671 if (PyErr_Occurred()) SWIG_fail;
23672 }
23673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23674 return resultobj;
23675 fail:
23676 return NULL;
23677 }
23678
23679
23680 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23681 PyObject *resultobj = 0;
23682 wxDateTime *arg1 = (wxDateTime *) 0 ;
23683 wxDateTime::WeekDay arg2 ;
23684 wxDateTime result;
23685 void *argp1 = 0 ;
23686 int res1 = 0 ;
23687 int val2 ;
23688 int ecode2 = 0 ;
23689 PyObject * obj0 = 0 ;
23690 PyObject * obj1 = 0 ;
23691 char * kwnames[] = {
23692 (char *) "self",(char *) "weekday", NULL
23693 };
23694
23695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23697 if (!SWIG_IsOK(res1)) {
23698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23699 }
23700 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23701 ecode2 = SWIG_AsVal_int(obj1, &val2);
23702 if (!SWIG_IsOK(ecode2)) {
23703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23704 }
23705 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23706 {
23707 PyThreadState* __tstate = wxPyBeginAllowThreads();
23708 result = (arg1)->GetNextWeekDay(arg2);
23709 wxPyEndAllowThreads(__tstate);
23710 if (PyErr_Occurred()) SWIG_fail;
23711 }
23712 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23720 PyObject *resultobj = 0;
23721 wxDateTime *arg1 = (wxDateTime *) 0 ;
23722 wxDateTime::WeekDay arg2 ;
23723 wxDateTime *result = 0 ;
23724 void *argp1 = 0 ;
23725 int res1 = 0 ;
23726 int val2 ;
23727 int ecode2 = 0 ;
23728 PyObject * obj0 = 0 ;
23729 PyObject * obj1 = 0 ;
23730 char * kwnames[] = {
23731 (char *) "self",(char *) "weekday", NULL
23732 };
23733
23734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23736 if (!SWIG_IsOK(res1)) {
23737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23738 }
23739 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23740 ecode2 = SWIG_AsVal_int(obj1, &val2);
23741 if (!SWIG_IsOK(ecode2)) {
23742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23743 }
23744 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23745 {
23746 PyThreadState* __tstate = wxPyBeginAllowThreads();
23747 {
23748 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23749 result = (wxDateTime *) &_result_ref;
23750 }
23751 wxPyEndAllowThreads(__tstate);
23752 if (PyErr_Occurred()) SWIG_fail;
23753 }
23754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23755 return resultobj;
23756 fail:
23757 return NULL;
23758 }
23759
23760
23761 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23762 PyObject *resultobj = 0;
23763 wxDateTime *arg1 = (wxDateTime *) 0 ;
23764 wxDateTime::WeekDay arg2 ;
23765 wxDateTime result;
23766 void *argp1 = 0 ;
23767 int res1 = 0 ;
23768 int val2 ;
23769 int ecode2 = 0 ;
23770 PyObject * obj0 = 0 ;
23771 PyObject * obj1 = 0 ;
23772 char * kwnames[] = {
23773 (char *) "self",(char *) "weekday", NULL
23774 };
23775
23776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23778 if (!SWIG_IsOK(res1)) {
23779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23780 }
23781 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23782 ecode2 = SWIG_AsVal_int(obj1, &val2);
23783 if (!SWIG_IsOK(ecode2)) {
23784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23785 }
23786 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23787 {
23788 PyThreadState* __tstate = wxPyBeginAllowThreads();
23789 result = (arg1)->GetPrevWeekDay(arg2);
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23794 return resultobj;
23795 fail:
23796 return NULL;
23797 }
23798
23799
23800 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23801 PyObject *resultobj = 0;
23802 wxDateTime *arg1 = (wxDateTime *) 0 ;
23803 wxDateTime::WeekDay arg2 ;
23804 int arg3 = (int) 1 ;
23805 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23806 int arg5 = (int) wxDateTime::Inv_Year ;
23807 bool result;
23808 void *argp1 = 0 ;
23809 int res1 = 0 ;
23810 int val2 ;
23811 int ecode2 = 0 ;
23812 int val3 ;
23813 int ecode3 = 0 ;
23814 int val4 ;
23815 int ecode4 = 0 ;
23816 int val5 ;
23817 int ecode5 = 0 ;
23818 PyObject * obj0 = 0 ;
23819 PyObject * obj1 = 0 ;
23820 PyObject * obj2 = 0 ;
23821 PyObject * obj3 = 0 ;
23822 PyObject * obj4 = 0 ;
23823 char * kwnames[] = {
23824 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23825 };
23826
23827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23829 if (!SWIG_IsOK(res1)) {
23830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23831 }
23832 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23833 ecode2 = SWIG_AsVal_int(obj1, &val2);
23834 if (!SWIG_IsOK(ecode2)) {
23835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23836 }
23837 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23838 if (obj2) {
23839 ecode3 = SWIG_AsVal_int(obj2, &val3);
23840 if (!SWIG_IsOK(ecode3)) {
23841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23842 }
23843 arg3 = static_cast< int >(val3);
23844 }
23845 if (obj3) {
23846 ecode4 = SWIG_AsVal_int(obj3, &val4);
23847 if (!SWIG_IsOK(ecode4)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23849 }
23850 arg4 = static_cast< wxDateTime::Month >(val4);
23851 }
23852 if (obj4) {
23853 ecode5 = SWIG_AsVal_int(obj4, &val5);
23854 if (!SWIG_IsOK(ecode5)) {
23855 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23856 }
23857 arg5 = static_cast< int >(val5);
23858 }
23859 {
23860 PyThreadState* __tstate = wxPyBeginAllowThreads();
23861 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23862 wxPyEndAllowThreads(__tstate);
23863 if (PyErr_Occurred()) SWIG_fail;
23864 }
23865 {
23866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23867 }
23868 return resultobj;
23869 fail:
23870 return NULL;
23871 }
23872
23873
23874 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23875 PyObject *resultobj = 0;
23876 wxDateTime *arg1 = (wxDateTime *) 0 ;
23877 wxDateTime::WeekDay arg2 ;
23878 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23879 int arg4 = (int) wxDateTime::Inv_Year ;
23880 bool result;
23881 void *argp1 = 0 ;
23882 int res1 = 0 ;
23883 int val2 ;
23884 int ecode2 = 0 ;
23885 int val3 ;
23886 int ecode3 = 0 ;
23887 int val4 ;
23888 int ecode4 = 0 ;
23889 PyObject * obj0 = 0 ;
23890 PyObject * obj1 = 0 ;
23891 PyObject * obj2 = 0 ;
23892 PyObject * obj3 = 0 ;
23893 char * kwnames[] = {
23894 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23895 };
23896
23897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23899 if (!SWIG_IsOK(res1)) {
23900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23901 }
23902 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23903 ecode2 = SWIG_AsVal_int(obj1, &val2);
23904 if (!SWIG_IsOK(ecode2)) {
23905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23906 }
23907 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23908 if (obj2) {
23909 ecode3 = SWIG_AsVal_int(obj2, &val3);
23910 if (!SWIG_IsOK(ecode3)) {
23911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23912 }
23913 arg3 = static_cast< wxDateTime::Month >(val3);
23914 }
23915 if (obj3) {
23916 ecode4 = SWIG_AsVal_int(obj3, &val4);
23917 if (!SWIG_IsOK(ecode4)) {
23918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23919 }
23920 arg4 = static_cast< int >(val4);
23921 }
23922 {
23923 PyThreadState* __tstate = wxPyBeginAllowThreads();
23924 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23925 wxPyEndAllowThreads(__tstate);
23926 if (PyErr_Occurred()) SWIG_fail;
23927 }
23928 {
23929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23930 }
23931 return resultobj;
23932 fail:
23933 return NULL;
23934 }
23935
23936
23937 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23938 PyObject *resultobj = 0;
23939 wxDateTime *arg1 = (wxDateTime *) 0 ;
23940 wxDateTime::WeekDay arg2 ;
23941 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23942 int arg4 = (int) wxDateTime::Inv_Year ;
23943 wxDateTime result;
23944 void *argp1 = 0 ;
23945 int res1 = 0 ;
23946 int val2 ;
23947 int ecode2 = 0 ;
23948 int val3 ;
23949 int ecode3 = 0 ;
23950 int val4 ;
23951 int ecode4 = 0 ;
23952 PyObject * obj0 = 0 ;
23953 PyObject * obj1 = 0 ;
23954 PyObject * obj2 = 0 ;
23955 PyObject * obj3 = 0 ;
23956 char * kwnames[] = {
23957 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23958 };
23959
23960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23962 if (!SWIG_IsOK(res1)) {
23963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23964 }
23965 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23966 ecode2 = SWIG_AsVal_int(obj1, &val2);
23967 if (!SWIG_IsOK(ecode2)) {
23968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23969 }
23970 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23971 if (obj2) {
23972 ecode3 = SWIG_AsVal_int(obj2, &val3);
23973 if (!SWIG_IsOK(ecode3)) {
23974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23975 }
23976 arg3 = static_cast< wxDateTime::Month >(val3);
23977 }
23978 if (obj3) {
23979 ecode4 = SWIG_AsVal_int(obj3, &val4);
23980 if (!SWIG_IsOK(ecode4)) {
23981 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23982 }
23983 arg4 = static_cast< int >(val4);
23984 }
23985 {
23986 PyThreadState* __tstate = wxPyBeginAllowThreads();
23987 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23988 wxPyEndAllowThreads(__tstate);
23989 if (PyErr_Occurred()) SWIG_fail;
23990 }
23991 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23992 return resultobj;
23993 fail:
23994 return NULL;
23995 }
23996
23997
23998 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23999 PyObject *resultobj = 0;
24000 wxDateTime *arg1 = (wxDateTime *) 0 ;
24001 int arg2 ;
24002 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24003 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24004 bool result;
24005 void *argp1 = 0 ;
24006 int res1 = 0 ;
24007 int val2 ;
24008 int ecode2 = 0 ;
24009 int val3 ;
24010 int ecode3 = 0 ;
24011 int val4 ;
24012 int ecode4 = 0 ;
24013 PyObject * obj0 = 0 ;
24014 PyObject * obj1 = 0 ;
24015 PyObject * obj2 = 0 ;
24016 PyObject * obj3 = 0 ;
24017 char * kwnames[] = {
24018 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24019 };
24020
24021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24023 if (!SWIG_IsOK(res1)) {
24024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24025 }
24026 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24027 ecode2 = SWIG_AsVal_int(obj1, &val2);
24028 if (!SWIG_IsOK(ecode2)) {
24029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
24030 }
24031 arg2 = static_cast< int >(val2);
24032 if (obj2) {
24033 ecode3 = SWIG_AsVal_int(obj2, &val3);
24034 if (!SWIG_IsOK(ecode3)) {
24035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24036 }
24037 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24038 }
24039 if (obj3) {
24040 ecode4 = SWIG_AsVal_int(obj3, &val4);
24041 if (!SWIG_IsOK(ecode4)) {
24042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24043 }
24044 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24045 }
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
24049 wxPyEndAllowThreads(__tstate);
24050 if (PyErr_Occurred()) SWIG_fail;
24051 }
24052 {
24053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24054 }
24055 return resultobj;
24056 fail:
24057 return NULL;
24058 }
24059
24060
24061 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24062 PyObject *resultobj = 0;
24063 wxDateTime *arg1 = (wxDateTime *) 0 ;
24064 int arg2 ;
24065 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24066 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24067 wxDateTime result;
24068 void *argp1 = 0 ;
24069 int res1 = 0 ;
24070 int val2 ;
24071 int ecode2 = 0 ;
24072 int val3 ;
24073 int ecode3 = 0 ;
24074 int val4 ;
24075 int ecode4 = 0 ;
24076 PyObject * obj0 = 0 ;
24077 PyObject * obj1 = 0 ;
24078 PyObject * obj2 = 0 ;
24079 PyObject * obj3 = 0 ;
24080 char * kwnames[] = {
24081 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24082 };
24083
24084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24086 if (!SWIG_IsOK(res1)) {
24087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24088 }
24089 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24090 ecode2 = SWIG_AsVal_int(obj1, &val2);
24091 if (!SWIG_IsOK(ecode2)) {
24092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
24093 }
24094 arg2 = static_cast< int >(val2);
24095 if (obj2) {
24096 ecode3 = SWIG_AsVal_int(obj2, &val3);
24097 if (!SWIG_IsOK(ecode3)) {
24098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24099 }
24100 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24101 }
24102 if (obj3) {
24103 ecode4 = SWIG_AsVal_int(obj3, &val4);
24104 if (!SWIG_IsOK(ecode4)) {
24105 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24106 }
24107 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24108 }
24109 {
24110 PyThreadState* __tstate = wxPyBeginAllowThreads();
24111 result = (arg1)->GetWeek(arg2,arg3,arg4);
24112 wxPyEndAllowThreads(__tstate);
24113 if (PyErr_Occurred()) SWIG_fail;
24114 }
24115 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24116 return resultobj;
24117 fail:
24118 return NULL;
24119 }
24120
24121
24122 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24123 PyObject *resultobj = 0;
24124 int arg1 ;
24125 int arg2 ;
24126 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24127 wxDateTime result;
24128 int val1 ;
24129 int ecode1 = 0 ;
24130 int val2 ;
24131 int ecode2 = 0 ;
24132 int val3 ;
24133 int ecode3 = 0 ;
24134 PyObject * obj0 = 0 ;
24135 PyObject * obj1 = 0 ;
24136 PyObject * obj2 = 0 ;
24137 char * kwnames[] = {
24138 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24139 };
24140
24141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24142 ecode1 = SWIG_AsVal_int(obj0, &val1);
24143 if (!SWIG_IsOK(ecode1)) {
24144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24145 }
24146 arg1 = static_cast< int >(val1);
24147 ecode2 = SWIG_AsVal_int(obj1, &val2);
24148 if (!SWIG_IsOK(ecode2)) {
24149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24150 }
24151 arg2 = static_cast< int >(val2);
24152 if (obj2) {
24153 ecode3 = SWIG_AsVal_int(obj2, &val3);
24154 if (!SWIG_IsOK(ecode3)) {
24155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24156 }
24157 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24158 }
24159 {
24160 PyThreadState* __tstate = wxPyBeginAllowThreads();
24161 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24162 wxPyEndAllowThreads(__tstate);
24163 if (PyErr_Occurred()) SWIG_fail;
24164 }
24165 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24173 PyObject *resultobj = 0;
24174 wxDateTime *arg1 = (wxDateTime *) 0 ;
24175 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24176 int arg3 = (int) wxDateTime::Inv_Year ;
24177 wxDateTime *result = 0 ;
24178 void *argp1 = 0 ;
24179 int res1 = 0 ;
24180 int val2 ;
24181 int ecode2 = 0 ;
24182 int val3 ;
24183 int ecode3 = 0 ;
24184 PyObject * obj0 = 0 ;
24185 PyObject * obj1 = 0 ;
24186 PyObject * obj2 = 0 ;
24187 char * kwnames[] = {
24188 (char *) "self",(char *) "month",(char *) "year", NULL
24189 };
24190
24191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24193 if (!SWIG_IsOK(res1)) {
24194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24195 }
24196 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24197 if (obj1) {
24198 ecode2 = SWIG_AsVal_int(obj1, &val2);
24199 if (!SWIG_IsOK(ecode2)) {
24200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24201 }
24202 arg2 = static_cast< wxDateTime::Month >(val2);
24203 }
24204 if (obj2) {
24205 ecode3 = SWIG_AsVal_int(obj2, &val3);
24206 if (!SWIG_IsOK(ecode3)) {
24207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24208 }
24209 arg3 = static_cast< int >(val3);
24210 }
24211 {
24212 PyThreadState* __tstate = wxPyBeginAllowThreads();
24213 {
24214 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24215 result = (wxDateTime *) &_result_ref;
24216 }
24217 wxPyEndAllowThreads(__tstate);
24218 if (PyErr_Occurred()) SWIG_fail;
24219 }
24220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24221 return resultobj;
24222 fail:
24223 return NULL;
24224 }
24225
24226
24227 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24228 PyObject *resultobj = 0;
24229 wxDateTime *arg1 = (wxDateTime *) 0 ;
24230 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24231 int arg3 = (int) wxDateTime::Inv_Year ;
24232 wxDateTime result;
24233 void *argp1 = 0 ;
24234 int res1 = 0 ;
24235 int val2 ;
24236 int ecode2 = 0 ;
24237 int val3 ;
24238 int ecode3 = 0 ;
24239 PyObject * obj0 = 0 ;
24240 PyObject * obj1 = 0 ;
24241 PyObject * obj2 = 0 ;
24242 char * kwnames[] = {
24243 (char *) "self",(char *) "month",(char *) "year", NULL
24244 };
24245
24246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24248 if (!SWIG_IsOK(res1)) {
24249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24250 }
24251 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24252 if (obj1) {
24253 ecode2 = SWIG_AsVal_int(obj1, &val2);
24254 if (!SWIG_IsOK(ecode2)) {
24255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24256 }
24257 arg2 = static_cast< wxDateTime::Month >(val2);
24258 }
24259 if (obj2) {
24260 ecode3 = SWIG_AsVal_int(obj2, &val3);
24261 if (!SWIG_IsOK(ecode3)) {
24262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24263 }
24264 arg3 = static_cast< int >(val3);
24265 }
24266 {
24267 PyThreadState* __tstate = wxPyBeginAllowThreads();
24268 result = (arg1)->GetLastMonthDay(arg2,arg3);
24269 wxPyEndAllowThreads(__tstate);
24270 if (PyErr_Occurred()) SWIG_fail;
24271 }
24272 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24280 PyObject *resultobj = 0;
24281 wxDateTime *arg1 = (wxDateTime *) 0 ;
24282 int arg2 ;
24283 wxDateTime *result = 0 ;
24284 void *argp1 = 0 ;
24285 int res1 = 0 ;
24286 int val2 ;
24287 int ecode2 = 0 ;
24288 PyObject * obj0 = 0 ;
24289 PyObject * obj1 = 0 ;
24290 char * kwnames[] = {
24291 (char *) "self",(char *) "yday", NULL
24292 };
24293
24294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24296 if (!SWIG_IsOK(res1)) {
24297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24298 }
24299 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24300 ecode2 = SWIG_AsVal_int(obj1, &val2);
24301 if (!SWIG_IsOK(ecode2)) {
24302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24303 }
24304 arg2 = static_cast< int >(val2);
24305 {
24306 PyThreadState* __tstate = wxPyBeginAllowThreads();
24307 {
24308 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24309 result = (wxDateTime *) &_result_ref;
24310 }
24311 wxPyEndAllowThreads(__tstate);
24312 if (PyErr_Occurred()) SWIG_fail;
24313 }
24314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24315 return resultobj;
24316 fail:
24317 return NULL;
24318 }
24319
24320
24321 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24322 PyObject *resultobj = 0;
24323 wxDateTime *arg1 = (wxDateTime *) 0 ;
24324 int arg2 ;
24325 wxDateTime result;
24326 void *argp1 = 0 ;
24327 int res1 = 0 ;
24328 int val2 ;
24329 int ecode2 = 0 ;
24330 PyObject * obj0 = 0 ;
24331 PyObject * obj1 = 0 ;
24332 char * kwnames[] = {
24333 (char *) "self",(char *) "yday", NULL
24334 };
24335
24336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24338 if (!SWIG_IsOK(res1)) {
24339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24340 }
24341 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24342 ecode2 = SWIG_AsVal_int(obj1, &val2);
24343 if (!SWIG_IsOK(ecode2)) {
24344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24345 }
24346 arg2 = static_cast< int >(val2);
24347 {
24348 PyThreadState* __tstate = wxPyBeginAllowThreads();
24349 result = (arg1)->GetYearDay(arg2);
24350 wxPyEndAllowThreads(__tstate);
24351 if (PyErr_Occurred()) SWIG_fail;
24352 }
24353 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24354 return resultobj;
24355 fail:
24356 return NULL;
24357 }
24358
24359
24360 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24361 PyObject *resultobj = 0;
24362 wxDateTime *arg1 = (wxDateTime *) 0 ;
24363 double result;
24364 void *argp1 = 0 ;
24365 int res1 = 0 ;
24366 PyObject *swig_obj[1] ;
24367
24368 if (!args) SWIG_fail;
24369 swig_obj[0] = args;
24370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24371 if (!SWIG_IsOK(res1)) {
24372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24373 }
24374 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24375 {
24376 PyThreadState* __tstate = wxPyBeginAllowThreads();
24377 result = (double)(arg1)->GetJulianDayNumber();
24378 wxPyEndAllowThreads(__tstate);
24379 if (PyErr_Occurred()) SWIG_fail;
24380 }
24381 resultobj = SWIG_From_double(static_cast< double >(result));
24382 return resultobj;
24383 fail:
24384 return NULL;
24385 }
24386
24387
24388 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24389 PyObject *resultobj = 0;
24390 wxDateTime *arg1 = (wxDateTime *) 0 ;
24391 double result;
24392 void *argp1 = 0 ;
24393 int res1 = 0 ;
24394 PyObject *swig_obj[1] ;
24395
24396 if (!args) SWIG_fail;
24397 swig_obj[0] = args;
24398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24399 if (!SWIG_IsOK(res1)) {
24400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24401 }
24402 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24403 {
24404 PyThreadState* __tstate = wxPyBeginAllowThreads();
24405 result = (double)(arg1)->GetJDN();
24406 wxPyEndAllowThreads(__tstate);
24407 if (PyErr_Occurred()) SWIG_fail;
24408 }
24409 resultobj = SWIG_From_double(static_cast< double >(result));
24410 return resultobj;
24411 fail:
24412 return NULL;
24413 }
24414
24415
24416 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24417 PyObject *resultobj = 0;
24418 wxDateTime *arg1 = (wxDateTime *) 0 ;
24419 double result;
24420 void *argp1 = 0 ;
24421 int res1 = 0 ;
24422 PyObject *swig_obj[1] ;
24423
24424 if (!args) SWIG_fail;
24425 swig_obj[0] = args;
24426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24427 if (!SWIG_IsOK(res1)) {
24428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24429 }
24430 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24431 {
24432 PyThreadState* __tstate = wxPyBeginAllowThreads();
24433 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24434 wxPyEndAllowThreads(__tstate);
24435 if (PyErr_Occurred()) SWIG_fail;
24436 }
24437 resultobj = SWIG_From_double(static_cast< double >(result));
24438 return resultobj;
24439 fail:
24440 return NULL;
24441 }
24442
24443
24444 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24445 PyObject *resultobj = 0;
24446 wxDateTime *arg1 = (wxDateTime *) 0 ;
24447 double result;
24448 void *argp1 = 0 ;
24449 int res1 = 0 ;
24450 PyObject *swig_obj[1] ;
24451
24452 if (!args) SWIG_fail;
24453 swig_obj[0] = args;
24454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24455 if (!SWIG_IsOK(res1)) {
24456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24457 }
24458 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24459 {
24460 PyThreadState* __tstate = wxPyBeginAllowThreads();
24461 result = (double)(arg1)->GetMJD();
24462 wxPyEndAllowThreads(__tstate);
24463 if (PyErr_Occurred()) SWIG_fail;
24464 }
24465 resultobj = SWIG_From_double(static_cast< double >(result));
24466 return resultobj;
24467 fail:
24468 return NULL;
24469 }
24470
24471
24472 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24473 PyObject *resultobj = 0;
24474 wxDateTime *arg1 = (wxDateTime *) 0 ;
24475 double result;
24476 void *argp1 = 0 ;
24477 int res1 = 0 ;
24478 PyObject *swig_obj[1] ;
24479
24480 if (!args) SWIG_fail;
24481 swig_obj[0] = args;
24482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24483 if (!SWIG_IsOK(res1)) {
24484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24485 }
24486 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24487 {
24488 PyThreadState* __tstate = wxPyBeginAllowThreads();
24489 result = (double)(arg1)->GetRataDie();
24490 wxPyEndAllowThreads(__tstate);
24491 if (PyErr_Occurred()) SWIG_fail;
24492 }
24493 resultobj = SWIG_From_double(static_cast< double >(result));
24494 return resultobj;
24495 fail:
24496 return NULL;
24497 }
24498
24499
24500 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24501 PyObject *resultobj = 0;
24502 wxDateTime *arg1 = (wxDateTime *) 0 ;
24503 wxDateTime::TimeZone *arg2 = 0 ;
24504 bool arg3 = (bool) false ;
24505 wxDateTime result;
24506 void *argp1 = 0 ;
24507 int res1 = 0 ;
24508 bool temp2 = false ;
24509 bool val3 ;
24510 int ecode3 = 0 ;
24511 PyObject * obj0 = 0 ;
24512 PyObject * obj1 = 0 ;
24513 PyObject * obj2 = 0 ;
24514 char * kwnames[] = {
24515 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24516 };
24517
24518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24520 if (!SWIG_IsOK(res1)) {
24521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24522 }
24523 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24524 {
24525 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24526 temp2 = true;
24527 }
24528 if (obj2) {
24529 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24530 if (!SWIG_IsOK(ecode3)) {
24531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24532 }
24533 arg3 = static_cast< bool >(val3);
24534 }
24535 {
24536 PyThreadState* __tstate = wxPyBeginAllowThreads();
24537 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24538 wxPyEndAllowThreads(__tstate);
24539 if (PyErr_Occurred()) SWIG_fail;
24540 }
24541 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24542 {
24543 if (temp2) delete arg2;
24544 }
24545 return resultobj;
24546 fail:
24547 {
24548 if (temp2) delete arg2;
24549 }
24550 return NULL;
24551 }
24552
24553
24554 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24555 PyObject *resultobj = 0;
24556 wxDateTime *arg1 = (wxDateTime *) 0 ;
24557 wxDateTime::TimeZone *arg2 = 0 ;
24558 bool arg3 = (bool) false ;
24559 wxDateTime *result = 0 ;
24560 void *argp1 = 0 ;
24561 int res1 = 0 ;
24562 bool temp2 = false ;
24563 bool val3 ;
24564 int ecode3 = 0 ;
24565 PyObject * obj0 = 0 ;
24566 PyObject * obj1 = 0 ;
24567 PyObject * obj2 = 0 ;
24568 char * kwnames[] = {
24569 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24570 };
24571
24572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24574 if (!SWIG_IsOK(res1)) {
24575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24576 }
24577 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24578 {
24579 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24580 temp2 = true;
24581 }
24582 if (obj2) {
24583 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24584 if (!SWIG_IsOK(ecode3)) {
24585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24586 }
24587 arg3 = static_cast< bool >(val3);
24588 }
24589 {
24590 PyThreadState* __tstate = wxPyBeginAllowThreads();
24591 {
24592 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24593 result = (wxDateTime *) &_result_ref;
24594 }
24595 wxPyEndAllowThreads(__tstate);
24596 if (PyErr_Occurred()) SWIG_fail;
24597 }
24598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24599 {
24600 if (temp2) delete arg2;
24601 }
24602 return resultobj;
24603 fail:
24604 {
24605 if (temp2) delete arg2;
24606 }
24607 return NULL;
24608 }
24609
24610
24611 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24612 PyObject *resultobj = 0;
24613 wxDateTime *arg1 = (wxDateTime *) 0 ;
24614 wxDateTime::TimeZone *arg2 = 0 ;
24615 bool arg3 = (bool) false ;
24616 wxDateTime result;
24617 void *argp1 = 0 ;
24618 int res1 = 0 ;
24619 bool temp2 = false ;
24620 bool val3 ;
24621 int ecode3 = 0 ;
24622 PyObject * obj0 = 0 ;
24623 PyObject * obj1 = 0 ;
24624 PyObject * obj2 = 0 ;
24625 char * kwnames[] = {
24626 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24627 };
24628
24629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24631 if (!SWIG_IsOK(res1)) {
24632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24633 }
24634 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24635 {
24636 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24637 temp2 = true;
24638 }
24639 if (obj2) {
24640 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24641 if (!SWIG_IsOK(ecode3)) {
24642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24643 }
24644 arg3 = static_cast< bool >(val3);
24645 }
24646 {
24647 PyThreadState* __tstate = wxPyBeginAllowThreads();
24648 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24649 wxPyEndAllowThreads(__tstate);
24650 if (PyErr_Occurred()) SWIG_fail;
24651 }
24652 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24653 {
24654 if (temp2) delete arg2;
24655 }
24656 return resultobj;
24657 fail:
24658 {
24659 if (temp2) delete arg2;
24660 }
24661 return NULL;
24662 }
24663
24664
24665 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24666 PyObject *resultobj = 0;
24667 wxDateTime *arg1 = (wxDateTime *) 0 ;
24668 wxDateTime::TimeZone *arg2 = 0 ;
24669 bool arg3 = (bool) false ;
24670 wxDateTime *result = 0 ;
24671 void *argp1 = 0 ;
24672 int res1 = 0 ;
24673 bool temp2 = false ;
24674 bool val3 ;
24675 int ecode3 = 0 ;
24676 PyObject * obj0 = 0 ;
24677 PyObject * obj1 = 0 ;
24678 PyObject * obj2 = 0 ;
24679 char * kwnames[] = {
24680 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24681 };
24682
24683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24685 if (!SWIG_IsOK(res1)) {
24686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24687 }
24688 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24689 {
24690 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24691 temp2 = true;
24692 }
24693 if (obj2) {
24694 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24695 if (!SWIG_IsOK(ecode3)) {
24696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24697 }
24698 arg3 = static_cast< bool >(val3);
24699 }
24700 {
24701 PyThreadState* __tstate = wxPyBeginAllowThreads();
24702 {
24703 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24704 result = (wxDateTime *) &_result_ref;
24705 }
24706 wxPyEndAllowThreads(__tstate);
24707 if (PyErr_Occurred()) SWIG_fail;
24708 }
24709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24710 {
24711 if (temp2) delete arg2;
24712 }
24713 return resultobj;
24714 fail:
24715 {
24716 if (temp2) delete arg2;
24717 }
24718 return NULL;
24719 }
24720
24721
24722 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24723 PyObject *resultobj = 0;
24724 wxDateTime *arg1 = (wxDateTime *) 0 ;
24725 bool arg2 = (bool) false ;
24726 wxDateTime result;
24727 void *argp1 = 0 ;
24728 int res1 = 0 ;
24729 bool val2 ;
24730 int ecode2 = 0 ;
24731 PyObject * obj0 = 0 ;
24732 PyObject * obj1 = 0 ;
24733 char * kwnames[] = {
24734 (char *) "self",(char *) "noDST", NULL
24735 };
24736
24737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24739 if (!SWIG_IsOK(res1)) {
24740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24741 }
24742 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24743 if (obj1) {
24744 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24745 if (!SWIG_IsOK(ecode2)) {
24746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24747 }
24748 arg2 = static_cast< bool >(val2);
24749 }
24750 {
24751 PyThreadState* __tstate = wxPyBeginAllowThreads();
24752 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24753 wxPyEndAllowThreads(__tstate);
24754 if (PyErr_Occurred()) SWIG_fail;
24755 }
24756 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24757 return resultobj;
24758 fail:
24759 return NULL;
24760 }
24761
24762
24763 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24764 PyObject *resultobj = 0;
24765 wxDateTime *arg1 = (wxDateTime *) 0 ;
24766 bool arg2 = (bool) false ;
24767 wxDateTime *result = 0 ;
24768 void *argp1 = 0 ;
24769 int res1 = 0 ;
24770 bool val2 ;
24771 int ecode2 = 0 ;
24772 PyObject * obj0 = 0 ;
24773 PyObject * obj1 = 0 ;
24774 char * kwnames[] = {
24775 (char *) "self",(char *) "noDST", NULL
24776 };
24777
24778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24780 if (!SWIG_IsOK(res1)) {
24781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24782 }
24783 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24784 if (obj1) {
24785 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24786 if (!SWIG_IsOK(ecode2)) {
24787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24788 }
24789 arg2 = static_cast< bool >(val2);
24790 }
24791 {
24792 PyThreadState* __tstate = wxPyBeginAllowThreads();
24793 {
24794 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24795 result = (wxDateTime *) &_result_ref;
24796 }
24797 wxPyEndAllowThreads(__tstate);
24798 if (PyErr_Occurred()) SWIG_fail;
24799 }
24800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24801 return resultobj;
24802 fail:
24803 return NULL;
24804 }
24805
24806
24807 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24808 PyObject *resultobj = 0;
24809 wxDateTime *arg1 = (wxDateTime *) 0 ;
24810 bool arg2 = (bool) false ;
24811 wxDateTime result;
24812 void *argp1 = 0 ;
24813 int res1 = 0 ;
24814 bool val2 ;
24815 int ecode2 = 0 ;
24816 PyObject * obj0 = 0 ;
24817 PyObject * obj1 = 0 ;
24818 char * kwnames[] = {
24819 (char *) "self",(char *) "noDST", NULL
24820 };
24821
24822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24824 if (!SWIG_IsOK(res1)) {
24825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24826 }
24827 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24828 if (obj1) {
24829 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24830 if (!SWIG_IsOK(ecode2)) {
24831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24832 }
24833 arg2 = static_cast< bool >(val2);
24834 }
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24838 wxPyEndAllowThreads(__tstate);
24839 if (PyErr_Occurred()) SWIG_fail;
24840 }
24841 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24842 return resultobj;
24843 fail:
24844 return NULL;
24845 }
24846
24847
24848 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24849 PyObject *resultobj = 0;
24850 wxDateTime *arg1 = (wxDateTime *) 0 ;
24851 bool arg2 = (bool) false ;
24852 wxDateTime *result = 0 ;
24853 void *argp1 = 0 ;
24854 int res1 = 0 ;
24855 bool val2 ;
24856 int ecode2 = 0 ;
24857 PyObject * obj0 = 0 ;
24858 PyObject * obj1 = 0 ;
24859 char * kwnames[] = {
24860 (char *) "self",(char *) "noDST", NULL
24861 };
24862
24863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24865 if (!SWIG_IsOK(res1)) {
24866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24867 }
24868 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24869 if (obj1) {
24870 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24871 if (!SWIG_IsOK(ecode2)) {
24872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24873 }
24874 arg2 = static_cast< bool >(val2);
24875 }
24876 {
24877 PyThreadState* __tstate = wxPyBeginAllowThreads();
24878 {
24879 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24880 result = (wxDateTime *) &_result_ref;
24881 }
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24893 PyObject *resultobj = 0;
24894 wxDateTime *arg1 = (wxDateTime *) 0 ;
24895 bool arg2 = (bool) false ;
24896 wxDateTime result;
24897 void *argp1 = 0 ;
24898 int res1 = 0 ;
24899 bool val2 ;
24900 int ecode2 = 0 ;
24901 PyObject * obj0 = 0 ;
24902 PyObject * obj1 = 0 ;
24903 char * kwnames[] = {
24904 (char *) "self",(char *) "noDST", NULL
24905 };
24906
24907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24909 if (!SWIG_IsOK(res1)) {
24910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24911 }
24912 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24913 if (obj1) {
24914 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24915 if (!SWIG_IsOK(ecode2)) {
24916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24917 }
24918 arg2 = static_cast< bool >(val2);
24919 }
24920 {
24921 PyThreadState* __tstate = wxPyBeginAllowThreads();
24922 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24923 wxPyEndAllowThreads(__tstate);
24924 if (PyErr_Occurred()) SWIG_fail;
24925 }
24926 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24927 return resultobj;
24928 fail:
24929 return NULL;
24930 }
24931
24932
24933 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24934 PyObject *resultobj = 0;
24935 wxDateTime *arg1 = (wxDateTime *) 0 ;
24936 bool arg2 = (bool) false ;
24937 wxDateTime *result = 0 ;
24938 void *argp1 = 0 ;
24939 int res1 = 0 ;
24940 bool val2 ;
24941 int ecode2 = 0 ;
24942 PyObject * obj0 = 0 ;
24943 PyObject * obj1 = 0 ;
24944 char * kwnames[] = {
24945 (char *) "self",(char *) "noDST", NULL
24946 };
24947
24948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24950 if (!SWIG_IsOK(res1)) {
24951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24952 }
24953 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24954 if (obj1) {
24955 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24956 if (!SWIG_IsOK(ecode2)) {
24957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24958 }
24959 arg2 = static_cast< bool >(val2);
24960 }
24961 {
24962 PyThreadState* __tstate = wxPyBeginAllowThreads();
24963 {
24964 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24965 result = (wxDateTime *) &_result_ref;
24966 }
24967 wxPyEndAllowThreads(__tstate);
24968 if (PyErr_Occurred()) SWIG_fail;
24969 }
24970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24971 return resultobj;
24972 fail:
24973 return NULL;
24974 }
24975
24976
24977 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24978 PyObject *resultobj = 0;
24979 wxDateTime *arg1 = (wxDateTime *) 0 ;
24980 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24981 int result;
24982 void *argp1 = 0 ;
24983 int res1 = 0 ;
24984 int val2 ;
24985 int ecode2 = 0 ;
24986 PyObject * obj0 = 0 ;
24987 PyObject * obj1 = 0 ;
24988 char * kwnames[] = {
24989 (char *) "self",(char *) "country", NULL
24990 };
24991
24992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24994 if (!SWIG_IsOK(res1)) {
24995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24996 }
24997 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24998 if (obj1) {
24999 ecode2 = SWIG_AsVal_int(obj1, &val2);
25000 if (!SWIG_IsOK(ecode2)) {
25001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25002 }
25003 arg2 = static_cast< wxDateTime::Country >(val2);
25004 }
25005 {
25006 PyThreadState* __tstate = wxPyBeginAllowThreads();
25007 result = (int)(arg1)->IsDST(arg2);
25008 wxPyEndAllowThreads(__tstate);
25009 if (PyErr_Occurred()) SWIG_fail;
25010 }
25011 resultobj = SWIG_From_int(static_cast< int >(result));
25012 return resultobj;
25013 fail:
25014 return NULL;
25015 }
25016
25017
25018 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25019 PyObject *resultobj = 0;
25020 wxDateTime *arg1 = (wxDateTime *) 0 ;
25021 bool result;
25022 void *argp1 = 0 ;
25023 int res1 = 0 ;
25024 PyObject *swig_obj[1] ;
25025
25026 if (!args) SWIG_fail;
25027 swig_obj[0] = args;
25028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25029 if (!SWIG_IsOK(res1)) {
25030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25031 }
25032 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25033 {
25034 PyThreadState* __tstate = wxPyBeginAllowThreads();
25035 result = (bool)((wxDateTime const *)arg1)->IsValid();
25036 wxPyEndAllowThreads(__tstate);
25037 if (PyErr_Occurred()) SWIG_fail;
25038 }
25039 {
25040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25041 }
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25049 PyObject *resultobj = 0;
25050 wxDateTime *arg1 = (wxDateTime *) 0 ;
25051 time_t result;
25052 void *argp1 = 0 ;
25053 int res1 = 0 ;
25054 PyObject *swig_obj[1] ;
25055
25056 if (!args) SWIG_fail;
25057 swig_obj[0] = args;
25058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25059 if (!SWIG_IsOK(res1)) {
25060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25061 }
25062 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25063 {
25064 PyThreadState* __tstate = wxPyBeginAllowThreads();
25065 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
25066 wxPyEndAllowThreads(__tstate);
25067 if (PyErr_Occurred()) SWIG_fail;
25068 }
25069 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25070 return resultobj;
25071 fail:
25072 return NULL;
25073 }
25074
25075
25076 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25077 PyObject *resultobj = 0;
25078 wxDateTime *arg1 = (wxDateTime *) 0 ;
25079 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25080 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25081 int result;
25082 void *argp1 = 0 ;
25083 int res1 = 0 ;
25084 bool temp2 = false ;
25085 PyObject * obj0 = 0 ;
25086 PyObject * obj1 = 0 ;
25087 char * kwnames[] = {
25088 (char *) "self",(char *) "tz", NULL
25089 };
25090
25091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
25092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25093 if (!SWIG_IsOK(res1)) {
25094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25095 }
25096 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25097 if (obj1) {
25098 {
25099 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25100 temp2 = true;
25101 }
25102 }
25103 {
25104 PyThreadState* __tstate = wxPyBeginAllowThreads();
25105 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
25106 wxPyEndAllowThreads(__tstate);
25107 if (PyErr_Occurred()) SWIG_fail;
25108 }
25109 resultobj = SWIG_From_int(static_cast< int >(result));
25110 {
25111 if (temp2) delete arg2;
25112 }
25113 return resultobj;
25114 fail:
25115 {
25116 if (temp2) delete arg2;
25117 }
25118 return NULL;
25119 }
25120
25121
25122 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25123 PyObject *resultobj = 0;
25124 wxDateTime *arg1 = (wxDateTime *) 0 ;
25125 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25126 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25127 wxDateTime::Month result;
25128 void *argp1 = 0 ;
25129 int res1 = 0 ;
25130 bool temp2 = false ;
25131 PyObject * obj0 = 0 ;
25132 PyObject * obj1 = 0 ;
25133 char * kwnames[] = {
25134 (char *) "self",(char *) "tz", NULL
25135 };
25136
25137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25139 if (!SWIG_IsOK(res1)) {
25140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25141 }
25142 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25143 if (obj1) {
25144 {
25145 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25146 temp2 = true;
25147 }
25148 }
25149 {
25150 PyThreadState* __tstate = wxPyBeginAllowThreads();
25151 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25152 wxPyEndAllowThreads(__tstate);
25153 if (PyErr_Occurred()) SWIG_fail;
25154 }
25155 resultobj = SWIG_From_int(static_cast< int >(result));
25156 {
25157 if (temp2) delete arg2;
25158 }
25159 return resultobj;
25160 fail:
25161 {
25162 if (temp2) delete arg2;
25163 }
25164 return NULL;
25165 }
25166
25167
25168 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25169 PyObject *resultobj = 0;
25170 wxDateTime *arg1 = (wxDateTime *) 0 ;
25171 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25172 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25173 int result;
25174 void *argp1 = 0 ;
25175 int res1 = 0 ;
25176 bool temp2 = false ;
25177 PyObject * obj0 = 0 ;
25178 PyObject * obj1 = 0 ;
25179 char * kwnames[] = {
25180 (char *) "self",(char *) "tz", NULL
25181 };
25182
25183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25185 if (!SWIG_IsOK(res1)) {
25186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25187 }
25188 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25189 if (obj1) {
25190 {
25191 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25192 temp2 = true;
25193 }
25194 }
25195 {
25196 PyThreadState* __tstate = wxPyBeginAllowThreads();
25197 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25198 wxPyEndAllowThreads(__tstate);
25199 if (PyErr_Occurred()) SWIG_fail;
25200 }
25201 resultobj = SWIG_From_int(static_cast< int >(result));
25202 {
25203 if (temp2) delete arg2;
25204 }
25205 return resultobj;
25206 fail:
25207 {
25208 if (temp2) delete arg2;
25209 }
25210 return NULL;
25211 }
25212
25213
25214 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25215 PyObject *resultobj = 0;
25216 wxDateTime *arg1 = (wxDateTime *) 0 ;
25217 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25218 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25219 wxDateTime::WeekDay result;
25220 void *argp1 = 0 ;
25221 int res1 = 0 ;
25222 bool temp2 = false ;
25223 PyObject * obj0 = 0 ;
25224 PyObject * obj1 = 0 ;
25225 char * kwnames[] = {
25226 (char *) "self",(char *) "tz", NULL
25227 };
25228
25229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25231 if (!SWIG_IsOK(res1)) {
25232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25233 }
25234 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25235 if (obj1) {
25236 {
25237 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25238 temp2 = true;
25239 }
25240 }
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25244 wxPyEndAllowThreads(__tstate);
25245 if (PyErr_Occurred()) SWIG_fail;
25246 }
25247 resultobj = SWIG_From_int(static_cast< int >(result));
25248 {
25249 if (temp2) delete arg2;
25250 }
25251 return resultobj;
25252 fail:
25253 {
25254 if (temp2) delete arg2;
25255 }
25256 return NULL;
25257 }
25258
25259
25260 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25261 PyObject *resultobj = 0;
25262 wxDateTime *arg1 = (wxDateTime *) 0 ;
25263 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25264 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25265 int result;
25266 void *argp1 = 0 ;
25267 int res1 = 0 ;
25268 bool temp2 = false ;
25269 PyObject * obj0 = 0 ;
25270 PyObject * obj1 = 0 ;
25271 char * kwnames[] = {
25272 (char *) "self",(char *) "tz", NULL
25273 };
25274
25275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25277 if (!SWIG_IsOK(res1)) {
25278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25279 }
25280 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25281 if (obj1) {
25282 {
25283 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25284 temp2 = true;
25285 }
25286 }
25287 {
25288 PyThreadState* __tstate = wxPyBeginAllowThreads();
25289 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25290 wxPyEndAllowThreads(__tstate);
25291 if (PyErr_Occurred()) SWIG_fail;
25292 }
25293 resultobj = SWIG_From_int(static_cast< int >(result));
25294 {
25295 if (temp2) delete arg2;
25296 }
25297 return resultobj;
25298 fail:
25299 {
25300 if (temp2) delete arg2;
25301 }
25302 return NULL;
25303 }
25304
25305
25306 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25307 PyObject *resultobj = 0;
25308 wxDateTime *arg1 = (wxDateTime *) 0 ;
25309 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25310 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25311 int result;
25312 void *argp1 = 0 ;
25313 int res1 = 0 ;
25314 bool temp2 = false ;
25315 PyObject * obj0 = 0 ;
25316 PyObject * obj1 = 0 ;
25317 char * kwnames[] = {
25318 (char *) "self",(char *) "tz", NULL
25319 };
25320
25321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25323 if (!SWIG_IsOK(res1)) {
25324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25325 }
25326 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25327 if (obj1) {
25328 {
25329 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25330 temp2 = true;
25331 }
25332 }
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25336 wxPyEndAllowThreads(__tstate);
25337 if (PyErr_Occurred()) SWIG_fail;
25338 }
25339 resultobj = SWIG_From_int(static_cast< int >(result));
25340 {
25341 if (temp2) delete arg2;
25342 }
25343 return resultobj;
25344 fail:
25345 {
25346 if (temp2) delete arg2;
25347 }
25348 return NULL;
25349 }
25350
25351
25352 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25353 PyObject *resultobj = 0;
25354 wxDateTime *arg1 = (wxDateTime *) 0 ;
25355 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25356 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25357 int result;
25358 void *argp1 = 0 ;
25359 int res1 = 0 ;
25360 bool temp2 = false ;
25361 PyObject * obj0 = 0 ;
25362 PyObject * obj1 = 0 ;
25363 char * kwnames[] = {
25364 (char *) "self",(char *) "tz", NULL
25365 };
25366
25367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25369 if (!SWIG_IsOK(res1)) {
25370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25371 }
25372 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25373 if (obj1) {
25374 {
25375 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25376 temp2 = true;
25377 }
25378 }
25379 {
25380 PyThreadState* __tstate = wxPyBeginAllowThreads();
25381 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 resultobj = SWIG_From_int(static_cast< int >(result));
25386 {
25387 if (temp2) delete arg2;
25388 }
25389 return resultobj;
25390 fail:
25391 {
25392 if (temp2) delete arg2;
25393 }
25394 return NULL;
25395 }
25396
25397
25398 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25399 PyObject *resultobj = 0;
25400 wxDateTime *arg1 = (wxDateTime *) 0 ;
25401 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25402 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25403 int result;
25404 void *argp1 = 0 ;
25405 int res1 = 0 ;
25406 bool temp2 = false ;
25407 PyObject * obj0 = 0 ;
25408 PyObject * obj1 = 0 ;
25409 char * kwnames[] = {
25410 (char *) "self",(char *) "tz", NULL
25411 };
25412
25413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25415 if (!SWIG_IsOK(res1)) {
25416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25417 }
25418 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25419 if (obj1) {
25420 {
25421 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25422 temp2 = true;
25423 }
25424 }
25425 {
25426 PyThreadState* __tstate = wxPyBeginAllowThreads();
25427 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25428 wxPyEndAllowThreads(__tstate);
25429 if (PyErr_Occurred()) SWIG_fail;
25430 }
25431 resultobj = SWIG_From_int(static_cast< int >(result));
25432 {
25433 if (temp2) delete arg2;
25434 }
25435 return resultobj;
25436 fail:
25437 {
25438 if (temp2) delete arg2;
25439 }
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25445 PyObject *resultobj = 0;
25446 wxDateTime *arg1 = (wxDateTime *) 0 ;
25447 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25448 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25449 int result;
25450 void *argp1 = 0 ;
25451 int res1 = 0 ;
25452 bool temp2 = false ;
25453 PyObject * obj0 = 0 ;
25454 PyObject * obj1 = 0 ;
25455 char * kwnames[] = {
25456 (char *) "self",(char *) "tz", NULL
25457 };
25458
25459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25461 if (!SWIG_IsOK(res1)) {
25462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25463 }
25464 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25465 if (obj1) {
25466 {
25467 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25468 temp2 = true;
25469 }
25470 }
25471 {
25472 PyThreadState* __tstate = wxPyBeginAllowThreads();
25473 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25474 wxPyEndAllowThreads(__tstate);
25475 if (PyErr_Occurred()) SWIG_fail;
25476 }
25477 resultobj = SWIG_From_int(static_cast< int >(result));
25478 {
25479 if (temp2) delete arg2;
25480 }
25481 return resultobj;
25482 fail:
25483 {
25484 if (temp2) delete arg2;
25485 }
25486 return NULL;
25487 }
25488
25489
25490 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25491 PyObject *resultobj = 0;
25492 wxDateTime *arg1 = (wxDateTime *) 0 ;
25493 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25494 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25495 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25496 int result;
25497 void *argp1 = 0 ;
25498 int res1 = 0 ;
25499 int val2 ;
25500 int ecode2 = 0 ;
25501 bool temp3 = false ;
25502 PyObject * obj0 = 0 ;
25503 PyObject * obj1 = 0 ;
25504 PyObject * obj2 = 0 ;
25505 char * kwnames[] = {
25506 (char *) "self",(char *) "flags",(char *) "tz", NULL
25507 };
25508
25509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25511 if (!SWIG_IsOK(res1)) {
25512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25513 }
25514 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25515 if (obj1) {
25516 ecode2 = SWIG_AsVal_int(obj1, &val2);
25517 if (!SWIG_IsOK(ecode2)) {
25518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25519 }
25520 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25521 }
25522 if (obj2) {
25523 {
25524 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25525 temp3 = true;
25526 }
25527 }
25528 {
25529 PyThreadState* __tstate = wxPyBeginAllowThreads();
25530 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 resultobj = SWIG_From_int(static_cast< int >(result));
25535 {
25536 if (temp3) delete arg3;
25537 }
25538 return resultobj;
25539 fail:
25540 {
25541 if (temp3) delete arg3;
25542 }
25543 return NULL;
25544 }
25545
25546
25547 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25548 PyObject *resultobj = 0;
25549 wxDateTime *arg1 = (wxDateTime *) 0 ;
25550 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25551 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25552 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25553 int result;
25554 void *argp1 = 0 ;
25555 int res1 = 0 ;
25556 int val2 ;
25557 int ecode2 = 0 ;
25558 bool temp3 = false ;
25559 PyObject * obj0 = 0 ;
25560 PyObject * obj1 = 0 ;
25561 PyObject * obj2 = 0 ;
25562 char * kwnames[] = {
25563 (char *) "self",(char *) "flags",(char *) "tz", NULL
25564 };
25565
25566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25568 if (!SWIG_IsOK(res1)) {
25569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25570 }
25571 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25572 if (obj1) {
25573 ecode2 = SWIG_AsVal_int(obj1, &val2);
25574 if (!SWIG_IsOK(ecode2)) {
25575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25576 }
25577 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25578 }
25579 if (obj2) {
25580 {
25581 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25582 temp3 = true;
25583 }
25584 }
25585 {
25586 PyThreadState* __tstate = wxPyBeginAllowThreads();
25587 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25588 wxPyEndAllowThreads(__tstate);
25589 if (PyErr_Occurred()) SWIG_fail;
25590 }
25591 resultobj = SWIG_From_int(static_cast< int >(result));
25592 {
25593 if (temp3) delete arg3;
25594 }
25595 return resultobj;
25596 fail:
25597 {
25598 if (temp3) delete arg3;
25599 }
25600 return NULL;
25601 }
25602
25603
25604 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25605 PyObject *resultobj = 0;
25606 wxDateTime *arg1 = (wxDateTime *) 0 ;
25607 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25608 bool result;
25609 void *argp1 = 0 ;
25610 int res1 = 0 ;
25611 int val2 ;
25612 int ecode2 = 0 ;
25613 PyObject * obj0 = 0 ;
25614 PyObject * obj1 = 0 ;
25615 char * kwnames[] = {
25616 (char *) "self",(char *) "country", NULL
25617 };
25618
25619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25621 if (!SWIG_IsOK(res1)) {
25622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25623 }
25624 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25625 if (obj1) {
25626 ecode2 = SWIG_AsVal_int(obj1, &val2);
25627 if (!SWIG_IsOK(ecode2)) {
25628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25629 }
25630 arg2 = static_cast< wxDateTime::Country >(val2);
25631 }
25632 {
25633 PyThreadState* __tstate = wxPyBeginAllowThreads();
25634 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25635 wxPyEndAllowThreads(__tstate);
25636 if (PyErr_Occurred()) SWIG_fail;
25637 }
25638 {
25639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25640 }
25641 return resultobj;
25642 fail:
25643 return NULL;
25644 }
25645
25646
25647 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25648 PyObject *resultobj = 0;
25649 wxDateTime *arg1 = (wxDateTime *) 0 ;
25650 wxDateTime *arg2 = 0 ;
25651 bool result;
25652 void *argp1 = 0 ;
25653 int res1 = 0 ;
25654 void *argp2 = 0 ;
25655 int res2 = 0 ;
25656 PyObject * obj0 = 0 ;
25657 PyObject * obj1 = 0 ;
25658 char * kwnames[] = {
25659 (char *) "self",(char *) "datetime", NULL
25660 };
25661
25662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25664 if (!SWIG_IsOK(res1)) {
25665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25666 }
25667 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25668 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25669 if (!SWIG_IsOK(res2)) {
25670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25671 }
25672 if (!argp2) {
25673 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25674 }
25675 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25676 {
25677 PyThreadState* __tstate = wxPyBeginAllowThreads();
25678 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25679 wxPyEndAllowThreads(__tstate);
25680 if (PyErr_Occurred()) SWIG_fail;
25681 }
25682 {
25683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25684 }
25685 return resultobj;
25686 fail:
25687 return NULL;
25688 }
25689
25690
25691 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25692 PyObject *resultobj = 0;
25693 wxDateTime *arg1 = (wxDateTime *) 0 ;
25694 wxDateTime *arg2 = 0 ;
25695 bool result;
25696 void *argp1 = 0 ;
25697 int res1 = 0 ;
25698 void *argp2 = 0 ;
25699 int res2 = 0 ;
25700 PyObject * obj0 = 0 ;
25701 PyObject * obj1 = 0 ;
25702 char * kwnames[] = {
25703 (char *) "self",(char *) "datetime", NULL
25704 };
25705
25706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25708 if (!SWIG_IsOK(res1)) {
25709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25710 }
25711 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25712 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25713 if (!SWIG_IsOK(res2)) {
25714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25715 }
25716 if (!argp2) {
25717 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25718 }
25719 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25720 {
25721 PyThreadState* __tstate = wxPyBeginAllowThreads();
25722 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25723 wxPyEndAllowThreads(__tstate);
25724 if (PyErr_Occurred()) SWIG_fail;
25725 }
25726 {
25727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25728 }
25729 return resultobj;
25730 fail:
25731 return NULL;
25732 }
25733
25734
25735 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25736 PyObject *resultobj = 0;
25737 wxDateTime *arg1 = (wxDateTime *) 0 ;
25738 wxDateTime *arg2 = 0 ;
25739 bool result;
25740 void *argp1 = 0 ;
25741 int res1 = 0 ;
25742 void *argp2 = 0 ;
25743 int res2 = 0 ;
25744 PyObject * obj0 = 0 ;
25745 PyObject * obj1 = 0 ;
25746 char * kwnames[] = {
25747 (char *) "self",(char *) "datetime", NULL
25748 };
25749
25750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25752 if (!SWIG_IsOK(res1)) {
25753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25754 }
25755 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25756 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25757 if (!SWIG_IsOK(res2)) {
25758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25759 }
25760 if (!argp2) {
25761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25762 }
25763 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25767 wxPyEndAllowThreads(__tstate);
25768 if (PyErr_Occurred()) SWIG_fail;
25769 }
25770 {
25771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25772 }
25773 return resultobj;
25774 fail:
25775 return NULL;
25776 }
25777
25778
25779 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25780 PyObject *resultobj = 0;
25781 wxDateTime *arg1 = (wxDateTime *) 0 ;
25782 wxDateTime *arg2 = 0 ;
25783 wxDateTime *arg3 = 0 ;
25784 bool result;
25785 void *argp1 = 0 ;
25786 int res1 = 0 ;
25787 void *argp2 = 0 ;
25788 int res2 = 0 ;
25789 void *argp3 = 0 ;
25790 int res3 = 0 ;
25791 PyObject * obj0 = 0 ;
25792 PyObject * obj1 = 0 ;
25793 PyObject * obj2 = 0 ;
25794 char * kwnames[] = {
25795 (char *) "self",(char *) "t1",(char *) "t2", NULL
25796 };
25797
25798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25800 if (!SWIG_IsOK(res1)) {
25801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25802 }
25803 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25804 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25805 if (!SWIG_IsOK(res2)) {
25806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25807 }
25808 if (!argp2) {
25809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25810 }
25811 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25812 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25813 if (!SWIG_IsOK(res3)) {
25814 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25815 }
25816 if (!argp3) {
25817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25818 }
25819 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25820 {
25821 PyThreadState* __tstate = wxPyBeginAllowThreads();
25822 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25823 wxPyEndAllowThreads(__tstate);
25824 if (PyErr_Occurred()) SWIG_fail;
25825 }
25826 {
25827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25828 }
25829 return resultobj;
25830 fail:
25831 return NULL;
25832 }
25833
25834
25835 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25836 PyObject *resultobj = 0;
25837 wxDateTime *arg1 = (wxDateTime *) 0 ;
25838 wxDateTime *arg2 = 0 ;
25839 wxDateTime *arg3 = 0 ;
25840 bool result;
25841 void *argp1 = 0 ;
25842 int res1 = 0 ;
25843 void *argp2 = 0 ;
25844 int res2 = 0 ;
25845 void *argp3 = 0 ;
25846 int res3 = 0 ;
25847 PyObject * obj0 = 0 ;
25848 PyObject * obj1 = 0 ;
25849 PyObject * obj2 = 0 ;
25850 char * kwnames[] = {
25851 (char *) "self",(char *) "t1",(char *) "t2", NULL
25852 };
25853
25854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25856 if (!SWIG_IsOK(res1)) {
25857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25858 }
25859 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25860 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25861 if (!SWIG_IsOK(res2)) {
25862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25863 }
25864 if (!argp2) {
25865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25866 }
25867 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25868 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25869 if (!SWIG_IsOK(res3)) {
25870 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25871 }
25872 if (!argp3) {
25873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25874 }
25875 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25876 {
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25879 wxPyEndAllowThreads(__tstate);
25880 if (PyErr_Occurred()) SWIG_fail;
25881 }
25882 {
25883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25884 }
25885 return resultobj;
25886 fail:
25887 return NULL;
25888 }
25889
25890
25891 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25892 PyObject *resultobj = 0;
25893 wxDateTime *arg1 = (wxDateTime *) 0 ;
25894 wxDateTime *arg2 = 0 ;
25895 bool result;
25896 void *argp1 = 0 ;
25897 int res1 = 0 ;
25898 void *argp2 = 0 ;
25899 int res2 = 0 ;
25900 PyObject * obj0 = 0 ;
25901 PyObject * obj1 = 0 ;
25902 char * kwnames[] = {
25903 (char *) "self",(char *) "dt", NULL
25904 };
25905
25906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) 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_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25910 }
25911 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25912 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25913 if (!SWIG_IsOK(res2)) {
25914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25915 }
25916 if (!argp2) {
25917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25918 }
25919 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 {
25927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25928 }
25929 return resultobj;
25930 fail:
25931 return NULL;
25932 }
25933
25934
25935 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25936 PyObject *resultobj = 0;
25937 wxDateTime *arg1 = (wxDateTime *) 0 ;
25938 wxDateTime *arg2 = 0 ;
25939 bool result;
25940 void *argp1 = 0 ;
25941 int res1 = 0 ;
25942 void *argp2 = 0 ;
25943 int res2 = 0 ;
25944 PyObject * obj0 = 0 ;
25945 PyObject * obj1 = 0 ;
25946 char * kwnames[] = {
25947 (char *) "self",(char *) "dt", NULL
25948 };
25949
25950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25952 if (!SWIG_IsOK(res1)) {
25953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25954 }
25955 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25956 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25957 if (!SWIG_IsOK(res2)) {
25958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25959 }
25960 if (!argp2) {
25961 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25962 }
25963 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25967 wxPyEndAllowThreads(__tstate);
25968 if (PyErr_Occurred()) SWIG_fail;
25969 }
25970 {
25971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25972 }
25973 return resultobj;
25974 fail:
25975 return NULL;
25976 }
25977
25978
25979 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25980 PyObject *resultobj = 0;
25981 wxDateTime *arg1 = (wxDateTime *) 0 ;
25982 wxDateTime *arg2 = 0 ;
25983 wxTimeSpan *arg3 = 0 ;
25984 bool result;
25985 void *argp1 = 0 ;
25986 int res1 = 0 ;
25987 void *argp2 = 0 ;
25988 int res2 = 0 ;
25989 void *argp3 = 0 ;
25990 int res3 = 0 ;
25991 PyObject * obj0 = 0 ;
25992 PyObject * obj1 = 0 ;
25993 PyObject * obj2 = 0 ;
25994 char * kwnames[] = {
25995 (char *) "self",(char *) "dt",(char *) "ts", NULL
25996 };
25997
25998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26000 if (!SWIG_IsOK(res1)) {
26001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26002 }
26003 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26004 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26005 if (!SWIG_IsOK(res2)) {
26006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26007 }
26008 if (!argp2) {
26009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26010 }
26011 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26012 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26013 if (!SWIG_IsOK(res3)) {
26014 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26015 }
26016 if (!argp3) {
26017 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26018 }
26019 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26023 wxPyEndAllowThreads(__tstate);
26024 if (PyErr_Occurred()) SWIG_fail;
26025 }
26026 {
26027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26028 }
26029 return resultobj;
26030 fail:
26031 return NULL;
26032 }
26033
26034
26035 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26036 PyObject *resultobj = 0;
26037 wxDateTime *arg1 = (wxDateTime *) 0 ;
26038 wxTimeSpan *arg2 = 0 ;
26039 wxDateTime *result = 0 ;
26040 void *argp1 = 0 ;
26041 int res1 = 0 ;
26042 void *argp2 = 0 ;
26043 int res2 = 0 ;
26044 PyObject * obj0 = 0 ;
26045 PyObject * obj1 = 0 ;
26046 char * kwnames[] = {
26047 (char *) "self",(char *) "diff", NULL
26048 };
26049
26050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
26051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26052 if (!SWIG_IsOK(res1)) {
26053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26054 }
26055 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26056 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26057 if (!SWIG_IsOK(res2)) {
26058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26059 }
26060 if (!argp2) {
26061 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26062 }
26063 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26064 {
26065 PyThreadState* __tstate = wxPyBeginAllowThreads();
26066 {
26067 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
26068 result = (wxDateTime *) &_result_ref;
26069 }
26070 wxPyEndAllowThreads(__tstate);
26071 if (PyErr_Occurred()) SWIG_fail;
26072 }
26073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26074 return resultobj;
26075 fail:
26076 return NULL;
26077 }
26078
26079
26080 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26081 PyObject *resultobj = 0;
26082 wxDateTime *arg1 = (wxDateTime *) 0 ;
26083 wxDateSpan *arg2 = 0 ;
26084 wxDateTime *result = 0 ;
26085 void *argp1 = 0 ;
26086 int res1 = 0 ;
26087 void *argp2 = 0 ;
26088 int res2 = 0 ;
26089 PyObject * obj0 = 0 ;
26090 PyObject * obj1 = 0 ;
26091 char * kwnames[] = {
26092 (char *) "self",(char *) "diff", NULL
26093 };
26094
26095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
26096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26097 if (!SWIG_IsOK(res1)) {
26098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26099 }
26100 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26102 if (!SWIG_IsOK(res2)) {
26103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26104 }
26105 if (!argp2) {
26106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26107 }
26108 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26109 {
26110 PyThreadState* __tstate = wxPyBeginAllowThreads();
26111 {
26112 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26113 result = (wxDateTime *) &_result_ref;
26114 }
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26119 return resultobj;
26120 fail:
26121 return NULL;
26122 }
26123
26124
26125 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26126 PyObject *resultobj = 0;
26127 wxDateTime *arg1 = (wxDateTime *) 0 ;
26128 wxTimeSpan *arg2 = 0 ;
26129 wxDateTime *result = 0 ;
26130 void *argp1 = 0 ;
26131 int res1 = 0 ;
26132 void *argp2 = 0 ;
26133 int res2 = 0 ;
26134 PyObject * obj0 = 0 ;
26135 PyObject * obj1 = 0 ;
26136 char * kwnames[] = {
26137 (char *) "self",(char *) "diff", NULL
26138 };
26139
26140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",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_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26144 }
26145 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26147 if (!SWIG_IsOK(res2)) {
26148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26149 }
26150 if (!argp2) {
26151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26152 }
26153 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26154 {
26155 PyThreadState* __tstate = wxPyBeginAllowThreads();
26156 {
26157 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26158 result = (wxDateTime *) &_result_ref;
26159 }
26160 wxPyEndAllowThreads(__tstate);
26161 if (PyErr_Occurred()) SWIG_fail;
26162 }
26163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26164 return resultobj;
26165 fail:
26166 return NULL;
26167 }
26168
26169
26170 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26171 PyObject *resultobj = 0;
26172 wxDateTime *arg1 = (wxDateTime *) 0 ;
26173 wxDateSpan *arg2 = 0 ;
26174 wxDateTime *result = 0 ;
26175 void *argp1 = 0 ;
26176 int res1 = 0 ;
26177 void *argp2 = 0 ;
26178 int res2 = 0 ;
26179 PyObject * obj0 = 0 ;
26180 PyObject * obj1 = 0 ;
26181 char * kwnames[] = {
26182 (char *) "self",(char *) "diff", NULL
26183 };
26184
26185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26187 if (!SWIG_IsOK(res1)) {
26188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26189 }
26190 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26191 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26192 if (!SWIG_IsOK(res2)) {
26193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26194 }
26195 if (!argp2) {
26196 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26197 }
26198 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26199 {
26200 PyThreadState* __tstate = wxPyBeginAllowThreads();
26201 {
26202 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26203 result = (wxDateTime *) &_result_ref;
26204 }
26205 wxPyEndAllowThreads(__tstate);
26206 if (PyErr_Occurred()) SWIG_fail;
26207 }
26208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26209 return resultobj;
26210 fail:
26211 return NULL;
26212 }
26213
26214
26215 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26216 PyObject *resultobj = 0;
26217 wxDateTime *arg1 = (wxDateTime *) 0 ;
26218 wxDateTime *arg2 = 0 ;
26219 wxTimeSpan result;
26220 void *argp1 = 0 ;
26221 int res1 = 0 ;
26222 void *argp2 = 0 ;
26223 int res2 = 0 ;
26224 PyObject * obj0 = 0 ;
26225 PyObject * obj1 = 0 ;
26226 char * kwnames[] = {
26227 (char *) "self",(char *) "dt", NULL
26228 };
26229
26230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26232 if (!SWIG_IsOK(res1)) {
26233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26234 }
26235 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26236 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26237 if (!SWIG_IsOK(res2)) {
26238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26239 }
26240 if (!argp2) {
26241 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26242 }
26243 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26244 {
26245 PyThreadState* __tstate = wxPyBeginAllowThreads();
26246 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26258 PyObject *resultobj = 0;
26259 wxDateTime *arg1 = (wxDateTime *) 0 ;
26260 wxTimeSpan *arg2 = 0 ;
26261 wxDateTime *result = 0 ;
26262 void *argp1 = 0 ;
26263 int res1 = 0 ;
26264 void *argp2 = 0 ;
26265 int res2 = 0 ;
26266
26267 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26269 if (!SWIG_IsOK(res1)) {
26270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26271 }
26272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26273 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26274 if (!SWIG_IsOK(res2)) {
26275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26276 }
26277 if (!argp2) {
26278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26279 }
26280 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26281 {
26282 PyThreadState* __tstate = wxPyBeginAllowThreads();
26283 {
26284 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26285 result = (wxDateTime *) &_result_ref;
26286 }
26287 wxPyEndAllowThreads(__tstate);
26288 if (PyErr_Occurred()) SWIG_fail;
26289 }
26290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26291 return resultobj;
26292 fail:
26293 return NULL;
26294 }
26295
26296
26297 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26298 PyObject *resultobj = 0;
26299 wxDateTime *arg1 = (wxDateTime *) 0 ;
26300 wxDateSpan *arg2 = 0 ;
26301 wxDateTime *result = 0 ;
26302 void *argp1 = 0 ;
26303 int res1 = 0 ;
26304 void *argp2 = 0 ;
26305 int res2 = 0 ;
26306
26307 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26309 if (!SWIG_IsOK(res1)) {
26310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26311 }
26312 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26313 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26314 if (!SWIG_IsOK(res2)) {
26315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26316 }
26317 if (!argp2) {
26318 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26319 }
26320 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26321 {
26322 PyThreadState* __tstate = wxPyBeginAllowThreads();
26323 {
26324 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26325 result = (wxDateTime *) &_result_ref;
26326 }
26327 wxPyEndAllowThreads(__tstate);
26328 if (PyErr_Occurred()) SWIG_fail;
26329 }
26330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26331 return resultobj;
26332 fail:
26333 return NULL;
26334 }
26335
26336
26337 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26338 int argc;
26339 PyObject *argv[3];
26340
26341 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26342 --argc;
26343 if (argc == 2) {
26344 int _v = 0;
26345 {
26346 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26347 _v = SWIG_CheckState(res);
26348 }
26349 if (!_v) goto check_1;
26350 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26351 }
26352 check_1:
26353
26354 if (argc == 2) {
26355 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26356 }
26357
26358 fail:
26359 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26360 return NULL;
26361 }
26362
26363
26364 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26365 PyObject *resultobj = 0;
26366 wxDateTime *arg1 = (wxDateTime *) 0 ;
26367 wxTimeSpan *arg2 = 0 ;
26368 wxDateTime *result = 0 ;
26369 void *argp1 = 0 ;
26370 int res1 = 0 ;
26371 void *argp2 = 0 ;
26372 int res2 = 0 ;
26373
26374 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26376 if (!SWIG_IsOK(res1)) {
26377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26378 }
26379 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26380 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26381 if (!SWIG_IsOK(res2)) {
26382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26383 }
26384 if (!argp2) {
26385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26386 }
26387 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26388 {
26389 PyThreadState* __tstate = wxPyBeginAllowThreads();
26390 {
26391 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26392 result = (wxDateTime *) &_result_ref;
26393 }
26394 wxPyEndAllowThreads(__tstate);
26395 if (PyErr_Occurred()) SWIG_fail;
26396 }
26397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26398 return resultobj;
26399 fail:
26400 return NULL;
26401 }
26402
26403
26404 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26405 PyObject *resultobj = 0;
26406 wxDateTime *arg1 = (wxDateTime *) 0 ;
26407 wxDateSpan *arg2 = 0 ;
26408 wxDateTime *result = 0 ;
26409 void *argp1 = 0 ;
26410 int res1 = 0 ;
26411 void *argp2 = 0 ;
26412 int res2 = 0 ;
26413
26414 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26416 if (!SWIG_IsOK(res1)) {
26417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26418 }
26419 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26420 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26421 if (!SWIG_IsOK(res2)) {
26422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26423 }
26424 if (!argp2) {
26425 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26426 }
26427 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26428 {
26429 PyThreadState* __tstate = wxPyBeginAllowThreads();
26430 {
26431 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26432 result = (wxDateTime *) &_result_ref;
26433 }
26434 wxPyEndAllowThreads(__tstate);
26435 if (PyErr_Occurred()) SWIG_fail;
26436 }
26437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26438 return resultobj;
26439 fail:
26440 return NULL;
26441 }
26442
26443
26444 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26445 int argc;
26446 PyObject *argv[3];
26447
26448 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26449 --argc;
26450 if (argc == 2) {
26451 int _v = 0;
26452 {
26453 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26454 _v = SWIG_CheckState(res);
26455 }
26456 if (!_v) goto check_1;
26457 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26458 }
26459 check_1:
26460
26461 if (argc == 2) {
26462 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26463 }
26464
26465 fail:
26466 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26467 return NULL;
26468 }
26469
26470
26471 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26472 PyObject *resultobj = 0;
26473 wxDateTime *arg1 = (wxDateTime *) 0 ;
26474 wxTimeSpan *arg2 = 0 ;
26475 wxDateTime result;
26476 void *argp1 = 0 ;
26477 int res1 = 0 ;
26478 void *argp2 = 0 ;
26479 int res2 = 0 ;
26480
26481 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26483 if (!SWIG_IsOK(res1)) {
26484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26485 }
26486 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26487 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26488 if (!SWIG_IsOK(res2)) {
26489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26490 }
26491 if (!argp2) {
26492 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26493 }
26494 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26495 {
26496 PyThreadState* __tstate = wxPyBeginAllowThreads();
26497 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26498 wxPyEndAllowThreads(__tstate);
26499 if (PyErr_Occurred()) SWIG_fail;
26500 }
26501 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26502 return resultobj;
26503 fail:
26504 return NULL;
26505 }
26506
26507
26508 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26509 PyObject *resultobj = 0;
26510 wxDateTime *arg1 = (wxDateTime *) 0 ;
26511 wxDateSpan *arg2 = 0 ;
26512 wxDateTime result;
26513 void *argp1 = 0 ;
26514 int res1 = 0 ;
26515 void *argp2 = 0 ;
26516 int res2 = 0 ;
26517
26518 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26520 if (!SWIG_IsOK(res1)) {
26521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26522 }
26523 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26524 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26525 if (!SWIG_IsOK(res2)) {
26526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26527 }
26528 if (!argp2) {
26529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26530 }
26531 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26532 {
26533 PyThreadState* __tstate = wxPyBeginAllowThreads();
26534 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26539 return resultobj;
26540 fail:
26541 return NULL;
26542 }
26543
26544
26545 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26546 int argc;
26547 PyObject *argv[3];
26548
26549 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26550 --argc;
26551 if (argc == 2) {
26552 int _v = 0;
26553 {
26554 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26555 _v = SWIG_CheckState(res);
26556 }
26557 if (!_v) goto check_1;
26558 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26559 }
26560 check_1:
26561
26562 if (argc == 2) {
26563 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26564 }
26565
26566 fail:
26567 Py_INCREF(Py_NotImplemented);
26568 return Py_NotImplemented;
26569 }
26570
26571
26572 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26573 PyObject *resultobj = 0;
26574 wxDateTime *arg1 = (wxDateTime *) 0 ;
26575 wxDateTime *arg2 = 0 ;
26576 wxTimeSpan result;
26577 void *argp1 = 0 ;
26578 int res1 = 0 ;
26579 void *argp2 = 0 ;
26580 int res2 = 0 ;
26581
26582 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26584 if (!SWIG_IsOK(res1)) {
26585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26586 }
26587 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26588 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26589 if (!SWIG_IsOK(res2)) {
26590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26591 }
26592 if (!argp2) {
26593 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26594 }
26595 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26596 {
26597 PyThreadState* __tstate = wxPyBeginAllowThreads();
26598 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26599 wxPyEndAllowThreads(__tstate);
26600 if (PyErr_Occurred()) SWIG_fail;
26601 }
26602 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26603 return resultobj;
26604 fail:
26605 return NULL;
26606 }
26607
26608
26609 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26610 PyObject *resultobj = 0;
26611 wxDateTime *arg1 = (wxDateTime *) 0 ;
26612 wxTimeSpan *arg2 = 0 ;
26613 wxDateTime result;
26614 void *argp1 = 0 ;
26615 int res1 = 0 ;
26616 void *argp2 = 0 ;
26617 int res2 = 0 ;
26618
26619 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26621 if (!SWIG_IsOK(res1)) {
26622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26623 }
26624 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26625 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26626 if (!SWIG_IsOK(res2)) {
26627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26628 }
26629 if (!argp2) {
26630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26631 }
26632 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26633 {
26634 PyThreadState* __tstate = wxPyBeginAllowThreads();
26635 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26636 wxPyEndAllowThreads(__tstate);
26637 if (PyErr_Occurred()) SWIG_fail;
26638 }
26639 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26640 return resultobj;
26641 fail:
26642 return NULL;
26643 }
26644
26645
26646 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26647 PyObject *resultobj = 0;
26648 wxDateTime *arg1 = (wxDateTime *) 0 ;
26649 wxDateSpan *arg2 = 0 ;
26650 wxDateTime result;
26651 void *argp1 = 0 ;
26652 int res1 = 0 ;
26653 void *argp2 = 0 ;
26654 int res2 = 0 ;
26655
26656 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26658 if (!SWIG_IsOK(res1)) {
26659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26660 }
26661 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26662 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26663 if (!SWIG_IsOK(res2)) {
26664 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26665 }
26666 if (!argp2) {
26667 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26668 }
26669 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26670 {
26671 PyThreadState* __tstate = wxPyBeginAllowThreads();
26672 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26673 wxPyEndAllowThreads(__tstate);
26674 if (PyErr_Occurred()) SWIG_fail;
26675 }
26676 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26677 return resultobj;
26678 fail:
26679 return NULL;
26680 }
26681
26682
26683 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26684 int argc;
26685 PyObject *argv[3];
26686
26687 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26688 --argc;
26689 if (argc == 2) {
26690 int _v = 0;
26691 {
26692 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26693 _v = SWIG_CheckState(res);
26694 }
26695 if (!_v) goto check_1;
26696 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26697 }
26698 check_1:
26699
26700 if (argc == 2) {
26701 int _v = 0;
26702 {
26703 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26704 _v = SWIG_CheckState(res);
26705 }
26706 if (!_v) goto check_2;
26707 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26708 }
26709 check_2:
26710
26711 if (argc == 2) {
26712 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26713 }
26714
26715 fail:
26716 Py_INCREF(Py_NotImplemented);
26717 return Py_NotImplemented;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26722 PyObject *resultobj = 0;
26723 wxDateTime *arg1 = (wxDateTime *) 0 ;
26724 wxDateTime *arg2 = (wxDateTime *) 0 ;
26725 bool result;
26726 void *argp1 = 0 ;
26727 int res1 = 0 ;
26728 void *argp2 = 0 ;
26729 int res2 = 0 ;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732 char * kwnames[] = {
26733 (char *) "self",(char *) "other", NULL
26734 };
26735
26736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",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___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26740 }
26741 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26742 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26743 if (!SWIG_IsOK(res2)) {
26744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26745 }
26746 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26747 {
26748 PyThreadState* __tstate = wxPyBeginAllowThreads();
26749 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26750 wxPyEndAllowThreads(__tstate);
26751 if (PyErr_Occurred()) SWIG_fail;
26752 }
26753 {
26754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26755 }
26756 return resultobj;
26757 fail:
26758 return NULL;
26759 }
26760
26761
26762 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26763 PyObject *resultobj = 0;
26764 wxDateTime *arg1 = (wxDateTime *) 0 ;
26765 wxDateTime *arg2 = (wxDateTime *) 0 ;
26766 bool result;
26767 void *argp1 = 0 ;
26768 int res1 = 0 ;
26769 void *argp2 = 0 ;
26770 int res2 = 0 ;
26771 PyObject * obj0 = 0 ;
26772 PyObject * obj1 = 0 ;
26773 char * kwnames[] = {
26774 (char *) "self",(char *) "other", NULL
26775 };
26776
26777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26779 if (!SWIG_IsOK(res1)) {
26780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26781 }
26782 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26784 if (!SWIG_IsOK(res2)) {
26785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26786 }
26787 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26788 {
26789 PyThreadState* __tstate = wxPyBeginAllowThreads();
26790 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26791 wxPyEndAllowThreads(__tstate);
26792 if (PyErr_Occurred()) SWIG_fail;
26793 }
26794 {
26795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26796 }
26797 return resultobj;
26798 fail:
26799 return NULL;
26800 }
26801
26802
26803 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26804 PyObject *resultobj = 0;
26805 wxDateTime *arg1 = (wxDateTime *) 0 ;
26806 wxDateTime *arg2 = (wxDateTime *) 0 ;
26807 bool result;
26808 void *argp1 = 0 ;
26809 int res1 = 0 ;
26810 void *argp2 = 0 ;
26811 int res2 = 0 ;
26812 PyObject * obj0 = 0 ;
26813 PyObject * obj1 = 0 ;
26814 char * kwnames[] = {
26815 (char *) "self",(char *) "other", NULL
26816 };
26817
26818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26820 if (!SWIG_IsOK(res1)) {
26821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26822 }
26823 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26825 if (!SWIG_IsOK(res2)) {
26826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26827 }
26828 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26832 wxPyEndAllowThreads(__tstate);
26833 if (PyErr_Occurred()) SWIG_fail;
26834 }
26835 {
26836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26837 }
26838 return resultobj;
26839 fail:
26840 return NULL;
26841 }
26842
26843
26844 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26845 PyObject *resultobj = 0;
26846 wxDateTime *arg1 = (wxDateTime *) 0 ;
26847 wxDateTime *arg2 = (wxDateTime *) 0 ;
26848 bool result;
26849 void *argp1 = 0 ;
26850 int res1 = 0 ;
26851 void *argp2 = 0 ;
26852 int res2 = 0 ;
26853 PyObject * obj0 = 0 ;
26854 PyObject * obj1 = 0 ;
26855 char * kwnames[] = {
26856 (char *) "self",(char *) "other", NULL
26857 };
26858
26859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26861 if (!SWIG_IsOK(res1)) {
26862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26863 }
26864 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26866 if (!SWIG_IsOK(res2)) {
26867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26868 }
26869 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26870 {
26871 PyThreadState* __tstate = wxPyBeginAllowThreads();
26872 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26873 wxPyEndAllowThreads(__tstate);
26874 if (PyErr_Occurred()) SWIG_fail;
26875 }
26876 {
26877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26878 }
26879 return resultobj;
26880 fail:
26881 return NULL;
26882 }
26883
26884
26885 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26886 PyObject *resultobj = 0;
26887 wxDateTime *arg1 = (wxDateTime *) 0 ;
26888 wxDateTime *arg2 = (wxDateTime *) 0 ;
26889 bool result;
26890 void *argp1 = 0 ;
26891 int res1 = 0 ;
26892 void *argp2 = 0 ;
26893 int res2 = 0 ;
26894 PyObject * obj0 = 0 ;
26895 PyObject * obj1 = 0 ;
26896 char * kwnames[] = {
26897 (char *) "self",(char *) "other", NULL
26898 };
26899
26900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26902 if (!SWIG_IsOK(res1)) {
26903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26904 }
26905 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26906 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26907 if (!SWIG_IsOK(res2)) {
26908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26909 }
26910 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26911 {
26912 PyThreadState* __tstate = wxPyBeginAllowThreads();
26913 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26914 wxPyEndAllowThreads(__tstate);
26915 if (PyErr_Occurred()) SWIG_fail;
26916 }
26917 {
26918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26919 }
26920 return resultobj;
26921 fail:
26922 return NULL;
26923 }
26924
26925
26926 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26927 PyObject *resultobj = 0;
26928 wxDateTime *arg1 = (wxDateTime *) 0 ;
26929 wxDateTime *arg2 = (wxDateTime *) 0 ;
26930 bool result;
26931 void *argp1 = 0 ;
26932 int res1 = 0 ;
26933 void *argp2 = 0 ;
26934 int res2 = 0 ;
26935 PyObject * obj0 = 0 ;
26936 PyObject * obj1 = 0 ;
26937 char * kwnames[] = {
26938 (char *) "self",(char *) "other", NULL
26939 };
26940
26941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26943 if (!SWIG_IsOK(res1)) {
26944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26945 }
26946 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26947 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26948 if (!SWIG_IsOK(res2)) {
26949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26950 }
26951 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26952 {
26953 PyThreadState* __tstate = wxPyBeginAllowThreads();
26954 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26955 wxPyEndAllowThreads(__tstate);
26956 if (PyErr_Occurred()) SWIG_fail;
26957 }
26958 {
26959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26960 }
26961 return resultobj;
26962 fail:
26963 return NULL;
26964 }
26965
26966
26967 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26968 PyObject *resultobj = 0;
26969 wxDateTime *arg1 = (wxDateTime *) 0 ;
26970 wxString *arg2 = 0 ;
26971 int result;
26972 void *argp1 = 0 ;
26973 int res1 = 0 ;
26974 bool temp2 = false ;
26975 PyObject * obj0 = 0 ;
26976 PyObject * obj1 = 0 ;
26977 char * kwnames[] = {
26978 (char *) "self",(char *) "date", NULL
26979 };
26980
26981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26983 if (!SWIG_IsOK(res1)) {
26984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26985 }
26986 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26987 {
26988 arg2 = wxString_in_helper(obj1);
26989 if (arg2 == NULL) SWIG_fail;
26990 temp2 = true;
26991 }
26992 {
26993 PyThreadState* __tstate = wxPyBeginAllowThreads();
26994 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26995 wxPyEndAllowThreads(__tstate);
26996 if (PyErr_Occurred()) SWIG_fail;
26997 }
26998 resultobj = SWIG_From_int(static_cast< int >(result));
26999 {
27000 if (temp2)
27001 delete arg2;
27002 }
27003 return resultobj;
27004 fail:
27005 {
27006 if (temp2)
27007 delete arg2;
27008 }
27009 return NULL;
27010 }
27011
27012
27013 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27014 PyObject *resultobj = 0;
27015 wxDateTime *arg1 = (wxDateTime *) 0 ;
27016 wxString *arg2 = 0 ;
27017 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27018 wxString *arg3 = (wxString *) &arg3_defvalue ;
27019 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27020 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27021 int result;
27022 void *argp1 = 0 ;
27023 int res1 = 0 ;
27024 bool temp2 = false ;
27025 bool temp3 = false ;
27026 void *argp4 = 0 ;
27027 int res4 = 0 ;
27028 PyObject * obj0 = 0 ;
27029 PyObject * obj1 = 0 ;
27030 PyObject * obj2 = 0 ;
27031 PyObject * obj3 = 0 ;
27032 char * kwnames[] = {
27033 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
27034 };
27035
27036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27038 if (!SWIG_IsOK(res1)) {
27039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
27040 }
27041 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27042 {
27043 arg2 = wxString_in_helper(obj1);
27044 if (arg2 == NULL) SWIG_fail;
27045 temp2 = true;
27046 }
27047 if (obj2) {
27048 {
27049 arg3 = wxString_in_helper(obj2);
27050 if (arg3 == NULL) SWIG_fail;
27051 temp3 = true;
27052 }
27053 }
27054 if (obj3) {
27055 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
27056 if (!SWIG_IsOK(res4)) {
27057 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27058 }
27059 if (!argp4) {
27060 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27061 }
27062 arg4 = reinterpret_cast< wxDateTime * >(argp4);
27063 }
27064 {
27065 PyThreadState* __tstate = wxPyBeginAllowThreads();
27066 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
27067 wxPyEndAllowThreads(__tstate);
27068 if (PyErr_Occurred()) SWIG_fail;
27069 }
27070 resultobj = SWIG_From_int(static_cast< int >(result));
27071 {
27072 if (temp2)
27073 delete arg2;
27074 }
27075 {
27076 if (temp3)
27077 delete arg3;
27078 }
27079 return resultobj;
27080 fail:
27081 {
27082 if (temp2)
27083 delete arg2;
27084 }
27085 {
27086 if (temp3)
27087 delete arg3;
27088 }
27089 return NULL;
27090 }
27091
27092
27093 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj = 0;
27095 wxDateTime *arg1 = (wxDateTime *) 0 ;
27096 wxString *arg2 = 0 ;
27097 int result;
27098 void *argp1 = 0 ;
27099 int res1 = 0 ;
27100 bool temp2 = false ;
27101 PyObject * obj0 = 0 ;
27102 PyObject * obj1 = 0 ;
27103 char * kwnames[] = {
27104 (char *) "self",(char *) "datetime", NULL
27105 };
27106
27107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
27108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27109 if (!SWIG_IsOK(res1)) {
27110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27111 }
27112 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27113 {
27114 arg2 = wxString_in_helper(obj1);
27115 if (arg2 == NULL) SWIG_fail;
27116 temp2 = true;
27117 }
27118 {
27119 PyThreadState* __tstate = wxPyBeginAllowThreads();
27120 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 resultobj = SWIG_From_int(static_cast< int >(result));
27125 {
27126 if (temp2)
27127 delete arg2;
27128 }
27129 return resultobj;
27130 fail:
27131 {
27132 if (temp2)
27133 delete arg2;
27134 }
27135 return NULL;
27136 }
27137
27138
27139 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27140 PyObject *resultobj = 0;
27141 wxDateTime *arg1 = (wxDateTime *) 0 ;
27142 wxString *arg2 = 0 ;
27143 int result;
27144 void *argp1 = 0 ;
27145 int res1 = 0 ;
27146 bool temp2 = false ;
27147 PyObject * obj0 = 0 ;
27148 PyObject * obj1 = 0 ;
27149 char * kwnames[] = {
27150 (char *) "self",(char *) "date", NULL
27151 };
27152
27153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27155 if (!SWIG_IsOK(res1)) {
27156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27157 }
27158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27159 {
27160 arg2 = wxString_in_helper(obj1);
27161 if (arg2 == NULL) SWIG_fail;
27162 temp2 = true;
27163 }
27164 {
27165 PyThreadState* __tstate = wxPyBeginAllowThreads();
27166 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27167 wxPyEndAllowThreads(__tstate);
27168 if (PyErr_Occurred()) SWIG_fail;
27169 }
27170 resultobj = SWIG_From_int(static_cast< int >(result));
27171 {
27172 if (temp2)
27173 delete arg2;
27174 }
27175 return resultobj;
27176 fail:
27177 {
27178 if (temp2)
27179 delete arg2;
27180 }
27181 return NULL;
27182 }
27183
27184
27185 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27186 PyObject *resultobj = 0;
27187 wxDateTime *arg1 = (wxDateTime *) 0 ;
27188 wxString *arg2 = 0 ;
27189 int result;
27190 void *argp1 = 0 ;
27191 int res1 = 0 ;
27192 bool temp2 = false ;
27193 PyObject * obj0 = 0 ;
27194 PyObject * obj1 = 0 ;
27195 char * kwnames[] = {
27196 (char *) "self",(char *) "time", NULL
27197 };
27198
27199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27201 if (!SWIG_IsOK(res1)) {
27202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27203 }
27204 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27205 {
27206 arg2 = wxString_in_helper(obj1);
27207 if (arg2 == NULL) SWIG_fail;
27208 temp2 = true;
27209 }
27210 {
27211 PyThreadState* __tstate = wxPyBeginAllowThreads();
27212 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27213 wxPyEndAllowThreads(__tstate);
27214 if (PyErr_Occurred()) SWIG_fail;
27215 }
27216 resultobj = SWIG_From_int(static_cast< int >(result));
27217 {
27218 if (temp2)
27219 delete arg2;
27220 }
27221 return resultobj;
27222 fail:
27223 {
27224 if (temp2)
27225 delete arg2;
27226 }
27227 return NULL;
27228 }
27229
27230
27231 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27232 PyObject *resultobj = 0;
27233 wxDateTime *arg1 = (wxDateTime *) 0 ;
27234 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27235 wxString *arg2 = (wxString *) &arg2_defvalue ;
27236 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27237 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27238 wxString result;
27239 void *argp1 = 0 ;
27240 int res1 = 0 ;
27241 bool temp2 = false ;
27242 bool temp3 = false ;
27243 PyObject * obj0 = 0 ;
27244 PyObject * obj1 = 0 ;
27245 PyObject * obj2 = 0 ;
27246 char * kwnames[] = {
27247 (char *) "self",(char *) "format",(char *) "tz", NULL
27248 };
27249
27250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27252 if (!SWIG_IsOK(res1)) {
27253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27254 }
27255 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27256 if (obj1) {
27257 {
27258 arg2 = wxString_in_helper(obj1);
27259 if (arg2 == NULL) SWIG_fail;
27260 temp2 = true;
27261 }
27262 }
27263 if (obj2) {
27264 {
27265 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27266 temp3 = true;
27267 }
27268 }
27269 {
27270 PyThreadState* __tstate = wxPyBeginAllowThreads();
27271 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27272 wxPyEndAllowThreads(__tstate);
27273 if (PyErr_Occurred()) SWIG_fail;
27274 }
27275 {
27276 #if wxUSE_UNICODE
27277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27278 #else
27279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27280 #endif
27281 }
27282 {
27283 if (temp2)
27284 delete arg2;
27285 }
27286 {
27287 if (temp3) delete arg3;
27288 }
27289 return resultobj;
27290 fail:
27291 {
27292 if (temp2)
27293 delete arg2;
27294 }
27295 {
27296 if (temp3) delete arg3;
27297 }
27298 return NULL;
27299 }
27300
27301
27302 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27303 PyObject *resultobj = 0;
27304 wxDateTime *arg1 = (wxDateTime *) 0 ;
27305 wxString result;
27306 void *argp1 = 0 ;
27307 int res1 = 0 ;
27308 PyObject *swig_obj[1] ;
27309
27310 if (!args) SWIG_fail;
27311 swig_obj[0] = args;
27312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27313 if (!SWIG_IsOK(res1)) {
27314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27315 }
27316 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27317 {
27318 PyThreadState* __tstate = wxPyBeginAllowThreads();
27319 result = ((wxDateTime const *)arg1)->FormatDate();
27320 wxPyEndAllowThreads(__tstate);
27321 if (PyErr_Occurred()) SWIG_fail;
27322 }
27323 {
27324 #if wxUSE_UNICODE
27325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27326 #else
27327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27328 #endif
27329 }
27330 return resultobj;
27331 fail:
27332 return NULL;
27333 }
27334
27335
27336 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27337 PyObject *resultobj = 0;
27338 wxDateTime *arg1 = (wxDateTime *) 0 ;
27339 wxString result;
27340 void *argp1 = 0 ;
27341 int res1 = 0 ;
27342 PyObject *swig_obj[1] ;
27343
27344 if (!args) SWIG_fail;
27345 swig_obj[0] = args;
27346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27347 if (!SWIG_IsOK(res1)) {
27348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27349 }
27350 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 result = ((wxDateTime const *)arg1)->FormatTime();
27354 wxPyEndAllowThreads(__tstate);
27355 if (PyErr_Occurred()) SWIG_fail;
27356 }
27357 {
27358 #if wxUSE_UNICODE
27359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27360 #else
27361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27362 #endif
27363 }
27364 return resultobj;
27365 fail:
27366 return NULL;
27367 }
27368
27369
27370 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27371 PyObject *resultobj = 0;
27372 wxDateTime *arg1 = (wxDateTime *) 0 ;
27373 wxString result;
27374 void *argp1 = 0 ;
27375 int res1 = 0 ;
27376 PyObject *swig_obj[1] ;
27377
27378 if (!args) SWIG_fail;
27379 swig_obj[0] = args;
27380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27381 if (!SWIG_IsOK(res1)) {
27382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27383 }
27384 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27385 {
27386 PyThreadState* __tstate = wxPyBeginAllowThreads();
27387 result = ((wxDateTime const *)arg1)->FormatISODate();
27388 wxPyEndAllowThreads(__tstate);
27389 if (PyErr_Occurred()) SWIG_fail;
27390 }
27391 {
27392 #if wxUSE_UNICODE
27393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27394 #else
27395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27396 #endif
27397 }
27398 return resultobj;
27399 fail:
27400 return NULL;
27401 }
27402
27403
27404 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27405 PyObject *resultobj = 0;
27406 wxDateTime *arg1 = (wxDateTime *) 0 ;
27407 wxString result;
27408 void *argp1 = 0 ;
27409 int res1 = 0 ;
27410 PyObject *swig_obj[1] ;
27411
27412 if (!args) SWIG_fail;
27413 swig_obj[0] = args;
27414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27415 if (!SWIG_IsOK(res1)) {
27416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27417 }
27418 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27419 {
27420 PyThreadState* __tstate = wxPyBeginAllowThreads();
27421 result = ((wxDateTime const *)arg1)->FormatISOTime();
27422 wxPyEndAllowThreads(__tstate);
27423 if (PyErr_Occurred()) SWIG_fail;
27424 }
27425 {
27426 #if wxUSE_UNICODE
27427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27428 #else
27429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27430 #endif
27431 }
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27439 PyObject *obj;
27440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27441 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27442 return SWIG_Py_Void();
27443 }
27444
27445 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27446 return SWIG_Python_InitShadowInstance(args);
27447 }
27448
27449 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27450 PyObject *resultobj = 0;
27451 long arg1 ;
27452 wxTimeSpan result;
27453 long val1 ;
27454 int ecode1 = 0 ;
27455 PyObject * obj0 = 0 ;
27456 char * kwnames[] = {
27457 (char *) "ms", NULL
27458 };
27459
27460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27461 ecode1 = SWIG_AsVal_long(obj0, &val1);
27462 if (!SWIG_IsOK(ecode1)) {
27463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27464 }
27465 arg1 = static_cast< long >(val1);
27466 {
27467 PyThreadState* __tstate = wxPyBeginAllowThreads();
27468 result = wxTimeSpan::Milliseconds(arg1);
27469 wxPyEndAllowThreads(__tstate);
27470 if (PyErr_Occurred()) SWIG_fail;
27471 }
27472 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27473 return resultobj;
27474 fail:
27475 return NULL;
27476 }
27477
27478
27479 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27480 PyObject *resultobj = 0;
27481 wxTimeSpan result;
27482
27483 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27484 {
27485 PyThreadState* __tstate = wxPyBeginAllowThreads();
27486 result = wxTimeSpan::Millisecond();
27487 wxPyEndAllowThreads(__tstate);
27488 if (PyErr_Occurred()) SWIG_fail;
27489 }
27490 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27491 return resultobj;
27492 fail:
27493 return NULL;
27494 }
27495
27496
27497 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27498 PyObject *resultobj = 0;
27499 long arg1 ;
27500 wxTimeSpan result;
27501 long val1 ;
27502 int ecode1 = 0 ;
27503 PyObject * obj0 = 0 ;
27504 char * kwnames[] = {
27505 (char *) "sec", NULL
27506 };
27507
27508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27509 ecode1 = SWIG_AsVal_long(obj0, &val1);
27510 if (!SWIG_IsOK(ecode1)) {
27511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27512 }
27513 arg1 = static_cast< long >(val1);
27514 {
27515 PyThreadState* __tstate = wxPyBeginAllowThreads();
27516 result = wxTimeSpan::Seconds(arg1);
27517 wxPyEndAllowThreads(__tstate);
27518 if (PyErr_Occurred()) SWIG_fail;
27519 }
27520 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27521 return resultobj;
27522 fail:
27523 return NULL;
27524 }
27525
27526
27527 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27528 PyObject *resultobj = 0;
27529 wxTimeSpan result;
27530
27531 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27532 {
27533 PyThreadState* __tstate = wxPyBeginAllowThreads();
27534 result = wxTimeSpan::Second();
27535 wxPyEndAllowThreads(__tstate);
27536 if (PyErr_Occurred()) SWIG_fail;
27537 }
27538 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27539 return resultobj;
27540 fail:
27541 return NULL;
27542 }
27543
27544
27545 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27546 PyObject *resultobj = 0;
27547 long arg1 ;
27548 wxTimeSpan result;
27549 long val1 ;
27550 int ecode1 = 0 ;
27551 PyObject * obj0 = 0 ;
27552 char * kwnames[] = {
27553 (char *) "min", NULL
27554 };
27555
27556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27557 ecode1 = SWIG_AsVal_long(obj0, &val1);
27558 if (!SWIG_IsOK(ecode1)) {
27559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27560 }
27561 arg1 = static_cast< long >(val1);
27562 {
27563 PyThreadState* __tstate = wxPyBeginAllowThreads();
27564 result = wxTimeSpan::Minutes(arg1);
27565 wxPyEndAllowThreads(__tstate);
27566 if (PyErr_Occurred()) SWIG_fail;
27567 }
27568 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27569 return resultobj;
27570 fail:
27571 return NULL;
27572 }
27573
27574
27575 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27576 PyObject *resultobj = 0;
27577 wxTimeSpan result;
27578
27579 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27580 {
27581 PyThreadState* __tstate = wxPyBeginAllowThreads();
27582 result = wxTimeSpan::Minute();
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj = 0;
27595 long arg1 ;
27596 wxTimeSpan result;
27597 long val1 ;
27598 int ecode1 = 0 ;
27599 PyObject * obj0 = 0 ;
27600 char * kwnames[] = {
27601 (char *) "hours", NULL
27602 };
27603
27604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27605 ecode1 = SWIG_AsVal_long(obj0, &val1);
27606 if (!SWIG_IsOK(ecode1)) {
27607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27608 }
27609 arg1 = static_cast< long >(val1);
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 result = wxTimeSpan::Hours(arg1);
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27624 PyObject *resultobj = 0;
27625 wxTimeSpan result;
27626
27627 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27628 {
27629 PyThreadState* __tstate = wxPyBeginAllowThreads();
27630 result = wxTimeSpan::Hour();
27631 wxPyEndAllowThreads(__tstate);
27632 if (PyErr_Occurred()) SWIG_fail;
27633 }
27634 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27635 return resultobj;
27636 fail:
27637 return NULL;
27638 }
27639
27640
27641 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27642 PyObject *resultobj = 0;
27643 long arg1 ;
27644 wxTimeSpan result;
27645 long val1 ;
27646 int ecode1 = 0 ;
27647 PyObject * obj0 = 0 ;
27648 char * kwnames[] = {
27649 (char *) "days", NULL
27650 };
27651
27652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27653 ecode1 = SWIG_AsVal_long(obj0, &val1);
27654 if (!SWIG_IsOK(ecode1)) {
27655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27656 }
27657 arg1 = static_cast< long >(val1);
27658 {
27659 PyThreadState* __tstate = wxPyBeginAllowThreads();
27660 result = wxTimeSpan::Days(arg1);
27661 wxPyEndAllowThreads(__tstate);
27662 if (PyErr_Occurred()) SWIG_fail;
27663 }
27664 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27665 return resultobj;
27666 fail:
27667 return NULL;
27668 }
27669
27670
27671 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27672 PyObject *resultobj = 0;
27673 wxTimeSpan result;
27674
27675 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27676 {
27677 PyThreadState* __tstate = wxPyBeginAllowThreads();
27678 result = wxTimeSpan::Day();
27679 wxPyEndAllowThreads(__tstate);
27680 if (PyErr_Occurred()) SWIG_fail;
27681 }
27682 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27683 return resultobj;
27684 fail:
27685 return NULL;
27686 }
27687
27688
27689 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27690 PyObject *resultobj = 0;
27691 long arg1 ;
27692 wxTimeSpan result;
27693 long val1 ;
27694 int ecode1 = 0 ;
27695 PyObject * obj0 = 0 ;
27696 char * kwnames[] = {
27697 (char *) "days", NULL
27698 };
27699
27700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27701 ecode1 = SWIG_AsVal_long(obj0, &val1);
27702 if (!SWIG_IsOK(ecode1)) {
27703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27704 }
27705 arg1 = static_cast< long >(val1);
27706 {
27707 PyThreadState* __tstate = wxPyBeginAllowThreads();
27708 result = wxTimeSpan::Weeks(arg1);
27709 wxPyEndAllowThreads(__tstate);
27710 if (PyErr_Occurred()) SWIG_fail;
27711 }
27712 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27713 return resultobj;
27714 fail:
27715 return NULL;
27716 }
27717
27718
27719 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27720 PyObject *resultobj = 0;
27721 wxTimeSpan result;
27722
27723 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27724 {
27725 PyThreadState* __tstate = wxPyBeginAllowThreads();
27726 result = wxTimeSpan::Week();
27727 wxPyEndAllowThreads(__tstate);
27728 if (PyErr_Occurred()) SWIG_fail;
27729 }
27730 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27731 return resultobj;
27732 fail:
27733 return NULL;
27734 }
27735
27736
27737 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27738 PyObject *resultobj = 0;
27739 long arg1 = (long) 0 ;
27740 long arg2 = (long) 0 ;
27741 long arg3 = (long) 0 ;
27742 long arg4 = (long) 0 ;
27743 wxTimeSpan *result = 0 ;
27744 long val1 ;
27745 int ecode1 = 0 ;
27746 long val2 ;
27747 int ecode2 = 0 ;
27748 long val3 ;
27749 int ecode3 = 0 ;
27750 long val4 ;
27751 int ecode4 = 0 ;
27752 PyObject * obj0 = 0 ;
27753 PyObject * obj1 = 0 ;
27754 PyObject * obj2 = 0 ;
27755 PyObject * obj3 = 0 ;
27756 char * kwnames[] = {
27757 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27758 };
27759
27760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27761 if (obj0) {
27762 ecode1 = SWIG_AsVal_long(obj0, &val1);
27763 if (!SWIG_IsOK(ecode1)) {
27764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27765 }
27766 arg1 = static_cast< long >(val1);
27767 }
27768 if (obj1) {
27769 ecode2 = SWIG_AsVal_long(obj1, &val2);
27770 if (!SWIG_IsOK(ecode2)) {
27771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27772 }
27773 arg2 = static_cast< long >(val2);
27774 }
27775 if (obj2) {
27776 ecode3 = SWIG_AsVal_long(obj2, &val3);
27777 if (!SWIG_IsOK(ecode3)) {
27778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27779 }
27780 arg3 = static_cast< long >(val3);
27781 }
27782 if (obj3) {
27783 ecode4 = SWIG_AsVal_long(obj3, &val4);
27784 if (!SWIG_IsOK(ecode4)) {
27785 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27786 }
27787 arg4 = static_cast< long >(val4);
27788 }
27789 {
27790 PyThreadState* __tstate = wxPyBeginAllowThreads();
27791 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27792 wxPyEndAllowThreads(__tstate);
27793 if (PyErr_Occurred()) SWIG_fail;
27794 }
27795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27803 PyObject *resultobj = 0;
27804 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27805 void *argp1 = 0 ;
27806 int res1 = 0 ;
27807 PyObject *swig_obj[1] ;
27808
27809 if (!args) SWIG_fail;
27810 swig_obj[0] = args;
27811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27812 if (!SWIG_IsOK(res1)) {
27813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27814 }
27815 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 delete arg1;
27819
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 resultobj = SWIG_Py_Void();
27824 return resultobj;
27825 fail:
27826 return NULL;
27827 }
27828
27829
27830 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27831 PyObject *resultobj = 0;
27832 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27833 wxTimeSpan *arg2 = 0 ;
27834 wxTimeSpan *result = 0 ;
27835 void *argp1 = 0 ;
27836 int res1 = 0 ;
27837 void *argp2 = 0 ;
27838 int res2 = 0 ;
27839 PyObject * obj0 = 0 ;
27840 PyObject * obj1 = 0 ;
27841 char * kwnames[] = {
27842 (char *) "self",(char *) "diff", NULL
27843 };
27844
27845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27847 if (!SWIG_IsOK(res1)) {
27848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27849 }
27850 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27851 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27852 if (!SWIG_IsOK(res2)) {
27853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27854 }
27855 if (!argp2) {
27856 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27857 }
27858 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27859 {
27860 PyThreadState* __tstate = wxPyBeginAllowThreads();
27861 {
27862 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27863 result = (wxTimeSpan *) &_result_ref;
27864 }
27865 wxPyEndAllowThreads(__tstate);
27866 if (PyErr_Occurred()) SWIG_fail;
27867 }
27868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27869 return resultobj;
27870 fail:
27871 return NULL;
27872 }
27873
27874
27875 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27876 PyObject *resultobj = 0;
27877 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27878 wxTimeSpan *arg2 = 0 ;
27879 wxTimeSpan *result = 0 ;
27880 void *argp1 = 0 ;
27881 int res1 = 0 ;
27882 void *argp2 = 0 ;
27883 int res2 = 0 ;
27884 PyObject * obj0 = 0 ;
27885 PyObject * obj1 = 0 ;
27886 char * kwnames[] = {
27887 (char *) "self",(char *) "diff", NULL
27888 };
27889
27890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27892 if (!SWIG_IsOK(res1)) {
27893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27894 }
27895 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27896 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27897 if (!SWIG_IsOK(res2)) {
27898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27899 }
27900 if (!argp2) {
27901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27902 }
27903 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27904 {
27905 PyThreadState* __tstate = wxPyBeginAllowThreads();
27906 {
27907 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27908 result = (wxTimeSpan *) &_result_ref;
27909 }
27910 wxPyEndAllowThreads(__tstate);
27911 if (PyErr_Occurred()) SWIG_fail;
27912 }
27913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27914 return resultobj;
27915 fail:
27916 return NULL;
27917 }
27918
27919
27920 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27921 PyObject *resultobj = 0;
27922 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27923 int arg2 ;
27924 wxTimeSpan *result = 0 ;
27925 void *argp1 = 0 ;
27926 int res1 = 0 ;
27927 int val2 ;
27928 int ecode2 = 0 ;
27929 PyObject * obj0 = 0 ;
27930 PyObject * obj1 = 0 ;
27931 char * kwnames[] = {
27932 (char *) "self",(char *) "n", NULL
27933 };
27934
27935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27937 if (!SWIG_IsOK(res1)) {
27938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27939 }
27940 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27941 ecode2 = SWIG_AsVal_int(obj1, &val2);
27942 if (!SWIG_IsOK(ecode2)) {
27943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27944 }
27945 arg2 = static_cast< int >(val2);
27946 {
27947 PyThreadState* __tstate = wxPyBeginAllowThreads();
27948 {
27949 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27950 result = (wxTimeSpan *) &_result_ref;
27951 }
27952 wxPyEndAllowThreads(__tstate);
27953 if (PyErr_Occurred()) SWIG_fail;
27954 }
27955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27956 return resultobj;
27957 fail:
27958 return NULL;
27959 }
27960
27961
27962 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27963 PyObject *resultobj = 0;
27964 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27965 wxTimeSpan *result = 0 ;
27966 void *argp1 = 0 ;
27967 int res1 = 0 ;
27968 PyObject *swig_obj[1] ;
27969
27970 if (!args) SWIG_fail;
27971 swig_obj[0] = args;
27972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27973 if (!SWIG_IsOK(res1)) {
27974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27975 }
27976 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 {
27980 wxTimeSpan &_result_ref = (arg1)->Neg();
27981 result = (wxTimeSpan *) &_result_ref;
27982 }
27983 wxPyEndAllowThreads(__tstate);
27984 if (PyErr_Occurred()) SWIG_fail;
27985 }
27986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27994 PyObject *resultobj = 0;
27995 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27996 wxTimeSpan result;
27997 void *argp1 = 0 ;
27998 int res1 = 0 ;
27999 PyObject *swig_obj[1] ;
28000
28001 if (!args) SWIG_fail;
28002 swig_obj[0] = args;
28003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28004 if (!SWIG_IsOK(res1)) {
28005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28006 }
28007 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 result = ((wxTimeSpan const *)arg1)->Abs();
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28022 PyObject *resultobj = 0;
28023 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28024 wxTimeSpan *arg2 = 0 ;
28025 wxTimeSpan *result = 0 ;
28026 void *argp1 = 0 ;
28027 int res1 = 0 ;
28028 void *argp2 = 0 ;
28029 int res2 = 0 ;
28030 PyObject * obj0 = 0 ;
28031 PyObject * obj1 = 0 ;
28032 char * kwnames[] = {
28033 (char *) "self",(char *) "diff", NULL
28034 };
28035
28036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
28037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28038 if (!SWIG_IsOK(res1)) {
28039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28040 }
28041 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28042 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28043 if (!SWIG_IsOK(res2)) {
28044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28045 }
28046 if (!argp2) {
28047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28048 }
28049 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28050 {
28051 PyThreadState* __tstate = wxPyBeginAllowThreads();
28052 {
28053 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
28054 result = (wxTimeSpan *) &_result_ref;
28055 }
28056 wxPyEndAllowThreads(__tstate);
28057 if (PyErr_Occurred()) SWIG_fail;
28058 }
28059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28060 return resultobj;
28061 fail:
28062 return NULL;
28063 }
28064
28065
28066 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28067 PyObject *resultobj = 0;
28068 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28069 wxTimeSpan *arg2 = 0 ;
28070 wxTimeSpan *result = 0 ;
28071 void *argp1 = 0 ;
28072 int res1 = 0 ;
28073 void *argp2 = 0 ;
28074 int res2 = 0 ;
28075 PyObject * obj0 = 0 ;
28076 PyObject * obj1 = 0 ;
28077 char * kwnames[] = {
28078 (char *) "self",(char *) "diff", NULL
28079 };
28080
28081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
28082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28083 if (!SWIG_IsOK(res1)) {
28084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28085 }
28086 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28087 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28088 if (!SWIG_IsOK(res2)) {
28089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28090 }
28091 if (!argp2) {
28092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28093 }
28094 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28095 {
28096 PyThreadState* __tstate = wxPyBeginAllowThreads();
28097 {
28098 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
28099 result = (wxTimeSpan *) &_result_ref;
28100 }
28101 wxPyEndAllowThreads(__tstate);
28102 if (PyErr_Occurred()) SWIG_fail;
28103 }
28104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28105 return resultobj;
28106 fail:
28107 return NULL;
28108 }
28109
28110
28111 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28112 PyObject *resultobj = 0;
28113 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28114 int arg2 ;
28115 wxTimeSpan *result = 0 ;
28116 void *argp1 = 0 ;
28117 int res1 = 0 ;
28118 int val2 ;
28119 int ecode2 = 0 ;
28120 PyObject * obj0 = 0 ;
28121 PyObject * obj1 = 0 ;
28122 char * kwnames[] = {
28123 (char *) "self",(char *) "n", NULL
28124 };
28125
28126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28128 if (!SWIG_IsOK(res1)) {
28129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28130 }
28131 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28132 ecode2 = SWIG_AsVal_int(obj1, &val2);
28133 if (!SWIG_IsOK(ecode2)) {
28134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28135 }
28136 arg2 = static_cast< int >(val2);
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 {
28140 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28141 result = (wxTimeSpan *) &_result_ref;
28142 }
28143 wxPyEndAllowThreads(__tstate);
28144 if (PyErr_Occurred()) SWIG_fail;
28145 }
28146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28147 return resultobj;
28148 fail:
28149 return NULL;
28150 }
28151
28152
28153 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28154 PyObject *resultobj = 0;
28155 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28156 wxTimeSpan *result = 0 ;
28157 void *argp1 = 0 ;
28158 int res1 = 0 ;
28159 PyObject *swig_obj[1] ;
28160
28161 if (!args) SWIG_fail;
28162 swig_obj[0] = args;
28163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28164 if (!SWIG_IsOK(res1)) {
28165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28166 }
28167 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28168 {
28169 PyThreadState* __tstate = wxPyBeginAllowThreads();
28170 {
28171 wxTimeSpan &_result_ref = (arg1)->operator -();
28172 result = (wxTimeSpan *) &_result_ref;
28173 }
28174 wxPyEndAllowThreads(__tstate);
28175 if (PyErr_Occurred()) SWIG_fail;
28176 }
28177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28178 return resultobj;
28179 fail:
28180 return NULL;
28181 }
28182
28183
28184 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28185 PyObject *resultobj = 0;
28186 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28187 wxTimeSpan *arg2 = 0 ;
28188 wxTimeSpan result;
28189 void *argp1 = 0 ;
28190 int res1 = 0 ;
28191 void *argp2 = 0 ;
28192 int res2 = 0 ;
28193 PyObject * obj0 = 0 ;
28194 PyObject * obj1 = 0 ;
28195 char * kwnames[] = {
28196 (char *) "self",(char *) "other", NULL
28197 };
28198
28199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28201 if (!SWIG_IsOK(res1)) {
28202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28203 }
28204 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28205 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28206 if (!SWIG_IsOK(res2)) {
28207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28208 }
28209 if (!argp2) {
28210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28211 }
28212 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28213 {
28214 PyThreadState* __tstate = wxPyBeginAllowThreads();
28215 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28216 wxPyEndAllowThreads(__tstate);
28217 if (PyErr_Occurred()) SWIG_fail;
28218 }
28219 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28227 PyObject *resultobj = 0;
28228 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28229 wxTimeSpan *arg2 = 0 ;
28230 wxTimeSpan result;
28231 void *argp1 = 0 ;
28232 int res1 = 0 ;
28233 void *argp2 = 0 ;
28234 int res2 = 0 ;
28235 PyObject * obj0 = 0 ;
28236 PyObject * obj1 = 0 ;
28237 char * kwnames[] = {
28238 (char *) "self",(char *) "other", NULL
28239 };
28240
28241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28243 if (!SWIG_IsOK(res1)) {
28244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28245 }
28246 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28247 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28248 if (!SWIG_IsOK(res2)) {
28249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28250 }
28251 if (!argp2) {
28252 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28253 }
28254 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28262 return resultobj;
28263 fail:
28264 return NULL;
28265 }
28266
28267
28268 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28269 PyObject *resultobj = 0;
28270 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28271 int arg2 ;
28272 wxTimeSpan result;
28273 void *argp1 = 0 ;
28274 int res1 = 0 ;
28275 int val2 ;
28276 int ecode2 = 0 ;
28277 PyObject * obj0 = 0 ;
28278 PyObject * obj1 = 0 ;
28279 char * kwnames[] = {
28280 (char *) "self",(char *) "n", NULL
28281 };
28282
28283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28285 if (!SWIG_IsOK(res1)) {
28286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28287 }
28288 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28289 ecode2 = SWIG_AsVal_int(obj1, &val2);
28290 if (!SWIG_IsOK(ecode2)) {
28291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28292 }
28293 arg2 = static_cast< int >(val2);
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = wxTimeSpan___mul__(arg1,arg2);
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28308 PyObject *resultobj = 0;
28309 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28310 int arg2 ;
28311 wxTimeSpan result;
28312 void *argp1 = 0 ;
28313 int res1 = 0 ;
28314 int val2 ;
28315 int ecode2 = 0 ;
28316 PyObject * obj0 = 0 ;
28317 PyObject * obj1 = 0 ;
28318 char * kwnames[] = {
28319 (char *) "self",(char *) "n", NULL
28320 };
28321
28322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28324 if (!SWIG_IsOK(res1)) {
28325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28326 }
28327 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28328 ecode2 = SWIG_AsVal_int(obj1, &val2);
28329 if (!SWIG_IsOK(ecode2)) {
28330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28331 }
28332 arg2 = static_cast< int >(val2);
28333 {
28334 PyThreadState* __tstate = wxPyBeginAllowThreads();
28335 result = wxTimeSpan___rmul__(arg1,arg2);
28336 wxPyEndAllowThreads(__tstate);
28337 if (PyErr_Occurred()) SWIG_fail;
28338 }
28339 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28340 return resultobj;
28341 fail:
28342 return NULL;
28343 }
28344
28345
28346 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28347 PyObject *resultobj = 0;
28348 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28349 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28350 bool result;
28351 void *argp1 = 0 ;
28352 int res1 = 0 ;
28353 void *argp2 = 0 ;
28354 int res2 = 0 ;
28355 PyObject * obj0 = 0 ;
28356 PyObject * obj1 = 0 ;
28357 char * kwnames[] = {
28358 (char *) "self",(char *) "other", NULL
28359 };
28360
28361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28363 if (!SWIG_IsOK(res1)) {
28364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28365 }
28366 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28367 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28368 if (!SWIG_IsOK(res2)) {
28369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28370 }
28371 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28372 {
28373 PyThreadState* __tstate = wxPyBeginAllowThreads();
28374 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28375 wxPyEndAllowThreads(__tstate);
28376 if (PyErr_Occurred()) SWIG_fail;
28377 }
28378 {
28379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28380 }
28381 return resultobj;
28382 fail:
28383 return NULL;
28384 }
28385
28386
28387 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28388 PyObject *resultobj = 0;
28389 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28390 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28391 bool result;
28392 void *argp1 = 0 ;
28393 int res1 = 0 ;
28394 void *argp2 = 0 ;
28395 int res2 = 0 ;
28396 PyObject * obj0 = 0 ;
28397 PyObject * obj1 = 0 ;
28398 char * kwnames[] = {
28399 (char *) "self",(char *) "other", NULL
28400 };
28401
28402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28404 if (!SWIG_IsOK(res1)) {
28405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28406 }
28407 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28409 if (!SWIG_IsOK(res2)) {
28410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28411 }
28412 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28416 wxPyEndAllowThreads(__tstate);
28417 if (PyErr_Occurred()) SWIG_fail;
28418 }
28419 {
28420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28421 }
28422 return resultobj;
28423 fail:
28424 return NULL;
28425 }
28426
28427
28428 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28429 PyObject *resultobj = 0;
28430 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28431 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28432 bool result;
28433 void *argp1 = 0 ;
28434 int res1 = 0 ;
28435 void *argp2 = 0 ;
28436 int res2 = 0 ;
28437 PyObject * obj0 = 0 ;
28438 PyObject * obj1 = 0 ;
28439 char * kwnames[] = {
28440 (char *) "self",(char *) "other", NULL
28441 };
28442
28443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28445 if (!SWIG_IsOK(res1)) {
28446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28447 }
28448 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28450 if (!SWIG_IsOK(res2)) {
28451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28452 }
28453 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 {
28461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28462 }
28463 return resultobj;
28464 fail:
28465 return NULL;
28466 }
28467
28468
28469 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28470 PyObject *resultobj = 0;
28471 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28472 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28473 bool result;
28474 void *argp1 = 0 ;
28475 int res1 = 0 ;
28476 void *argp2 = 0 ;
28477 int res2 = 0 ;
28478 PyObject * obj0 = 0 ;
28479 PyObject * obj1 = 0 ;
28480 char * kwnames[] = {
28481 (char *) "self",(char *) "other", NULL
28482 };
28483
28484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28486 if (!SWIG_IsOK(res1)) {
28487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28488 }
28489 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28490 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28491 if (!SWIG_IsOK(res2)) {
28492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28493 }
28494 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28495 {
28496 PyThreadState* __tstate = wxPyBeginAllowThreads();
28497 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28498 wxPyEndAllowThreads(__tstate);
28499 if (PyErr_Occurred()) SWIG_fail;
28500 }
28501 {
28502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28503 }
28504 return resultobj;
28505 fail:
28506 return NULL;
28507 }
28508
28509
28510 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28511 PyObject *resultobj = 0;
28512 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28513 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28514 bool result;
28515 void *argp1 = 0 ;
28516 int res1 = 0 ;
28517 void *argp2 = 0 ;
28518 int res2 = 0 ;
28519 PyObject * obj0 = 0 ;
28520 PyObject * obj1 = 0 ;
28521 char * kwnames[] = {
28522 (char *) "self",(char *) "other", NULL
28523 };
28524
28525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28527 if (!SWIG_IsOK(res1)) {
28528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28529 }
28530 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28531 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28532 if (!SWIG_IsOK(res2)) {
28533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28534 }
28535 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28536 {
28537 PyThreadState* __tstate = wxPyBeginAllowThreads();
28538 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28539 wxPyEndAllowThreads(__tstate);
28540 if (PyErr_Occurred()) SWIG_fail;
28541 }
28542 {
28543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28544 }
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj = 0;
28553 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28554 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28555 bool result;
28556 void *argp1 = 0 ;
28557 int res1 = 0 ;
28558 void *argp2 = 0 ;
28559 int res2 = 0 ;
28560 PyObject * obj0 = 0 ;
28561 PyObject * obj1 = 0 ;
28562 char * kwnames[] = {
28563 (char *) "self",(char *) "other", NULL
28564 };
28565
28566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28568 if (!SWIG_IsOK(res1)) {
28569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28570 }
28571 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28573 if (!SWIG_IsOK(res2)) {
28574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28575 }
28576 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28577 {
28578 PyThreadState* __tstate = wxPyBeginAllowThreads();
28579 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28580 wxPyEndAllowThreads(__tstate);
28581 if (PyErr_Occurred()) SWIG_fail;
28582 }
28583 {
28584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28585 }
28586 return resultobj;
28587 fail:
28588 return NULL;
28589 }
28590
28591
28592 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28593 PyObject *resultobj = 0;
28594 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28595 bool result;
28596 void *argp1 = 0 ;
28597 int res1 = 0 ;
28598 PyObject *swig_obj[1] ;
28599
28600 if (!args) SWIG_fail;
28601 swig_obj[0] = args;
28602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28603 if (!SWIG_IsOK(res1)) {
28604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28605 }
28606 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28607 {
28608 PyThreadState* __tstate = wxPyBeginAllowThreads();
28609 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28610 wxPyEndAllowThreads(__tstate);
28611 if (PyErr_Occurred()) SWIG_fail;
28612 }
28613 {
28614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28615 }
28616 return resultobj;
28617 fail:
28618 return NULL;
28619 }
28620
28621
28622 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28623 PyObject *resultobj = 0;
28624 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28625 bool result;
28626 void *argp1 = 0 ;
28627 int res1 = 0 ;
28628 PyObject *swig_obj[1] ;
28629
28630 if (!args) SWIG_fail;
28631 swig_obj[0] = args;
28632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28633 if (!SWIG_IsOK(res1)) {
28634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28635 }
28636 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28637 {
28638 PyThreadState* __tstate = wxPyBeginAllowThreads();
28639 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 {
28644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28645 }
28646 return resultobj;
28647 fail:
28648 return NULL;
28649 }
28650
28651
28652 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28653 PyObject *resultobj = 0;
28654 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28655 bool result;
28656 void *argp1 = 0 ;
28657 int res1 = 0 ;
28658 PyObject *swig_obj[1] ;
28659
28660 if (!args) SWIG_fail;
28661 swig_obj[0] = args;
28662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28663 if (!SWIG_IsOK(res1)) {
28664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28665 }
28666 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28667 {
28668 PyThreadState* __tstate = wxPyBeginAllowThreads();
28669 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 {
28674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28675 }
28676 return resultobj;
28677 fail:
28678 return NULL;
28679 }
28680
28681
28682 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28683 PyObject *resultobj = 0;
28684 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28685 wxTimeSpan *arg2 = 0 ;
28686 bool result;
28687 void *argp1 = 0 ;
28688 int res1 = 0 ;
28689 void *argp2 = 0 ;
28690 int res2 = 0 ;
28691 PyObject * obj0 = 0 ;
28692 PyObject * obj1 = 0 ;
28693 char * kwnames[] = {
28694 (char *) "self",(char *) "ts", NULL
28695 };
28696
28697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28699 if (!SWIG_IsOK(res1)) {
28700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28701 }
28702 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28703 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28704 if (!SWIG_IsOK(res2)) {
28705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28706 }
28707 if (!argp2) {
28708 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28709 }
28710 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28711 {
28712 PyThreadState* __tstate = wxPyBeginAllowThreads();
28713 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28714 wxPyEndAllowThreads(__tstate);
28715 if (PyErr_Occurred()) SWIG_fail;
28716 }
28717 {
28718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28719 }
28720 return resultobj;
28721 fail:
28722 return NULL;
28723 }
28724
28725
28726 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28727 PyObject *resultobj = 0;
28728 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28729 wxTimeSpan *arg2 = 0 ;
28730 bool result;
28731 void *argp1 = 0 ;
28732 int res1 = 0 ;
28733 void *argp2 = 0 ;
28734 int res2 = 0 ;
28735 PyObject * obj0 = 0 ;
28736 PyObject * obj1 = 0 ;
28737 char * kwnames[] = {
28738 (char *) "self",(char *) "ts", NULL
28739 };
28740
28741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28743 if (!SWIG_IsOK(res1)) {
28744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28745 }
28746 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28747 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28748 if (!SWIG_IsOK(res2)) {
28749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28750 }
28751 if (!argp2) {
28752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28753 }
28754 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28755 {
28756 PyThreadState* __tstate = wxPyBeginAllowThreads();
28757 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28758 wxPyEndAllowThreads(__tstate);
28759 if (PyErr_Occurred()) SWIG_fail;
28760 }
28761 {
28762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28763 }
28764 return resultobj;
28765 fail:
28766 return NULL;
28767 }
28768
28769
28770 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28771 PyObject *resultobj = 0;
28772 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28773 wxTimeSpan *arg2 = 0 ;
28774 bool result;
28775 void *argp1 = 0 ;
28776 int res1 = 0 ;
28777 void *argp2 = 0 ;
28778 int res2 = 0 ;
28779 PyObject * obj0 = 0 ;
28780 PyObject * obj1 = 0 ;
28781 char * kwnames[] = {
28782 (char *) "self",(char *) "t", NULL
28783 };
28784
28785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28787 if (!SWIG_IsOK(res1)) {
28788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28789 }
28790 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28791 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28792 if (!SWIG_IsOK(res2)) {
28793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28794 }
28795 if (!argp2) {
28796 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28797 }
28798 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28799 {
28800 PyThreadState* __tstate = wxPyBeginAllowThreads();
28801 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 {
28806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28807 }
28808 return resultobj;
28809 fail:
28810 return NULL;
28811 }
28812
28813
28814 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28815 PyObject *resultobj = 0;
28816 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28817 int result;
28818 void *argp1 = 0 ;
28819 int res1 = 0 ;
28820 PyObject *swig_obj[1] ;
28821
28822 if (!args) SWIG_fail;
28823 swig_obj[0] = args;
28824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28825 if (!SWIG_IsOK(res1)) {
28826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28827 }
28828 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 resultobj = SWIG_From_int(static_cast< int >(result));
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28843 PyObject *resultobj = 0;
28844 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28845 int result;
28846 void *argp1 = 0 ;
28847 int res1 = 0 ;
28848 PyObject *swig_obj[1] ;
28849
28850 if (!args) SWIG_fail;
28851 swig_obj[0] = args;
28852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28853 if (!SWIG_IsOK(res1)) {
28854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28855 }
28856 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28857 {
28858 PyThreadState* __tstate = wxPyBeginAllowThreads();
28859 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 resultobj = SWIG_From_int(static_cast< int >(result));
28864 return resultobj;
28865 fail:
28866 return NULL;
28867 }
28868
28869
28870 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28871 PyObject *resultobj = 0;
28872 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28873 int result;
28874 void *argp1 = 0 ;
28875 int res1 = 0 ;
28876 PyObject *swig_obj[1] ;
28877
28878 if (!args) SWIG_fail;
28879 swig_obj[0] = args;
28880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28881 if (!SWIG_IsOK(res1)) {
28882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28883 }
28884 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28885 {
28886 PyThreadState* __tstate = wxPyBeginAllowThreads();
28887 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28888 wxPyEndAllowThreads(__tstate);
28889 if (PyErr_Occurred()) SWIG_fail;
28890 }
28891 resultobj = SWIG_From_int(static_cast< int >(result));
28892 return resultobj;
28893 fail:
28894 return NULL;
28895 }
28896
28897
28898 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28899 PyObject *resultobj = 0;
28900 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28901 int result;
28902 void *argp1 = 0 ;
28903 int res1 = 0 ;
28904 PyObject *swig_obj[1] ;
28905
28906 if (!args) SWIG_fail;
28907 swig_obj[0] = args;
28908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28909 if (!SWIG_IsOK(res1)) {
28910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28911 }
28912 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28913 {
28914 PyThreadState* __tstate = wxPyBeginAllowThreads();
28915 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28916 wxPyEndAllowThreads(__tstate);
28917 if (PyErr_Occurred()) SWIG_fail;
28918 }
28919 resultobj = SWIG_From_int(static_cast< int >(result));
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28927 PyObject *resultobj = 0;
28928 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28929 wxLongLong result;
28930 void *argp1 = 0 ;
28931 int res1 = 0 ;
28932 PyObject *swig_obj[1] ;
28933
28934 if (!args) SWIG_fail;
28935 swig_obj[0] = args;
28936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28937 if (!SWIG_IsOK(res1)) {
28938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28939 }
28940 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 {
28948 PyObject *hi, *lo, *shifter, *shifted;
28949 hi = PyLong_FromLong( (&result)->GetHi() );
28950 lo = PyLong_FromLong( (&result)->GetLo() );
28951 shifter = PyLong_FromLong(32);
28952 shifted = PyNumber_Lshift(hi, shifter);
28953 resultobj = PyNumber_Or(shifted, lo);
28954 Py_DECREF(hi);
28955 Py_DECREF(lo);
28956 Py_DECREF(shifter);
28957 Py_DECREF(shifted);
28958 }
28959 return resultobj;
28960 fail:
28961 return NULL;
28962 }
28963
28964
28965 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28966 PyObject *resultobj = 0;
28967 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28968 wxLongLong result;
28969 void *argp1 = 0 ;
28970 int res1 = 0 ;
28971 PyObject *swig_obj[1] ;
28972
28973 if (!args) SWIG_fail;
28974 swig_obj[0] = args;
28975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28976 if (!SWIG_IsOK(res1)) {
28977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28978 }
28979 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28980 {
28981 PyThreadState* __tstate = wxPyBeginAllowThreads();
28982 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28983 wxPyEndAllowThreads(__tstate);
28984 if (PyErr_Occurred()) SWIG_fail;
28985 }
28986 {
28987 PyObject *hi, *lo, *shifter, *shifted;
28988 hi = PyLong_FromLong( (&result)->GetHi() );
28989 lo = PyLong_FromLong( (&result)->GetLo() );
28990 shifter = PyLong_FromLong(32);
28991 shifted = PyNumber_Lshift(hi, shifter);
28992 resultobj = PyNumber_Or(shifted, lo);
28993 Py_DECREF(hi);
28994 Py_DECREF(lo);
28995 Py_DECREF(shifter);
28996 Py_DECREF(shifted);
28997 }
28998 return resultobj;
28999 fail:
29000 return NULL;
29001 }
29002
29003
29004 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29005 PyObject *resultobj = 0;
29006 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29007 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29008 wxString *arg2 = (wxString *) &arg2_defvalue ;
29009 wxString result;
29010 void *argp1 = 0 ;
29011 int res1 = 0 ;
29012 bool temp2 = false ;
29013 PyObject * obj0 = 0 ;
29014 PyObject * obj1 = 0 ;
29015 char * kwnames[] = {
29016 (char *) "self",(char *) "format", NULL
29017 };
29018
29019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29021 if (!SWIG_IsOK(res1)) {
29022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29023 }
29024 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29025 if (obj1) {
29026 {
29027 arg2 = wxString_in_helper(obj1);
29028 if (arg2 == NULL) SWIG_fail;
29029 temp2 = true;
29030 }
29031 }
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
29035 wxPyEndAllowThreads(__tstate);
29036 if (PyErr_Occurred()) SWIG_fail;
29037 }
29038 {
29039 #if wxUSE_UNICODE
29040 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29041 #else
29042 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29043 #endif
29044 }
29045 {
29046 if (temp2)
29047 delete arg2;
29048 }
29049 return resultobj;
29050 fail:
29051 {
29052 if (temp2)
29053 delete arg2;
29054 }
29055 return NULL;
29056 }
29057
29058
29059 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29060 PyObject *obj;
29061 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29062 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
29063 return SWIG_Py_Void();
29064 }
29065
29066 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29067 return SWIG_Python_InitShadowInstance(args);
29068 }
29069
29070 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29071 PyObject *resultobj = 0;
29072 int arg1 = (int) 0 ;
29073 int arg2 = (int) 0 ;
29074 int arg3 = (int) 0 ;
29075 int arg4 = (int) 0 ;
29076 wxDateSpan *result = 0 ;
29077 int val1 ;
29078 int ecode1 = 0 ;
29079 int val2 ;
29080 int ecode2 = 0 ;
29081 int val3 ;
29082 int ecode3 = 0 ;
29083 int val4 ;
29084 int ecode4 = 0 ;
29085 PyObject * obj0 = 0 ;
29086 PyObject * obj1 = 0 ;
29087 PyObject * obj2 = 0 ;
29088 PyObject * obj3 = 0 ;
29089 char * kwnames[] = {
29090 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
29091 };
29092
29093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29094 if (obj0) {
29095 ecode1 = SWIG_AsVal_int(obj0, &val1);
29096 if (!SWIG_IsOK(ecode1)) {
29097 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
29098 }
29099 arg1 = static_cast< int >(val1);
29100 }
29101 if (obj1) {
29102 ecode2 = SWIG_AsVal_int(obj1, &val2);
29103 if (!SWIG_IsOK(ecode2)) {
29104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
29105 }
29106 arg2 = static_cast< int >(val2);
29107 }
29108 if (obj2) {
29109 ecode3 = SWIG_AsVal_int(obj2, &val3);
29110 if (!SWIG_IsOK(ecode3)) {
29111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
29112 }
29113 arg3 = static_cast< int >(val3);
29114 }
29115 if (obj3) {
29116 ecode4 = SWIG_AsVal_int(obj3, &val4);
29117 if (!SWIG_IsOK(ecode4)) {
29118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
29119 }
29120 arg4 = static_cast< int >(val4);
29121 }
29122 {
29123 PyThreadState* __tstate = wxPyBeginAllowThreads();
29124 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29136 PyObject *resultobj = 0;
29137 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29138 void *argp1 = 0 ;
29139 int res1 = 0 ;
29140 PyObject *swig_obj[1] ;
29141
29142 if (!args) SWIG_fail;
29143 swig_obj[0] = args;
29144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29145 if (!SWIG_IsOK(res1)) {
29146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29147 }
29148 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 delete arg1;
29152
29153 wxPyEndAllowThreads(__tstate);
29154 if (PyErr_Occurred()) SWIG_fail;
29155 }
29156 resultobj = SWIG_Py_Void();
29157 return resultobj;
29158 fail:
29159 return NULL;
29160 }
29161
29162
29163 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29164 PyObject *resultobj = 0;
29165 int arg1 ;
29166 wxDateSpan result;
29167 int val1 ;
29168 int ecode1 = 0 ;
29169 PyObject * obj0 = 0 ;
29170 char * kwnames[] = {
29171 (char *) "days", NULL
29172 };
29173
29174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29175 ecode1 = SWIG_AsVal_int(obj0, &val1);
29176 if (!SWIG_IsOK(ecode1)) {
29177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29178 }
29179 arg1 = static_cast< int >(val1);
29180 {
29181 PyThreadState* __tstate = wxPyBeginAllowThreads();
29182 result = wxDateSpan::Days(arg1);
29183 wxPyEndAllowThreads(__tstate);
29184 if (PyErr_Occurred()) SWIG_fail;
29185 }
29186 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29187 return resultobj;
29188 fail:
29189 return NULL;
29190 }
29191
29192
29193 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29194 PyObject *resultobj = 0;
29195 wxDateSpan result;
29196
29197 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29198 {
29199 PyThreadState* __tstate = wxPyBeginAllowThreads();
29200 result = wxDateSpan::Day();
29201 wxPyEndAllowThreads(__tstate);
29202 if (PyErr_Occurred()) SWIG_fail;
29203 }
29204 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29205 return resultobj;
29206 fail:
29207 return NULL;
29208 }
29209
29210
29211 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29212 PyObject *resultobj = 0;
29213 int arg1 ;
29214 wxDateSpan result;
29215 int val1 ;
29216 int ecode1 = 0 ;
29217 PyObject * obj0 = 0 ;
29218 char * kwnames[] = {
29219 (char *) "weeks", NULL
29220 };
29221
29222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29223 ecode1 = SWIG_AsVal_int(obj0, &val1);
29224 if (!SWIG_IsOK(ecode1)) {
29225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29226 }
29227 arg1 = static_cast< int >(val1);
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 result = wxDateSpan::Weeks(arg1);
29231 wxPyEndAllowThreads(__tstate);
29232 if (PyErr_Occurred()) SWIG_fail;
29233 }
29234 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29235 return resultobj;
29236 fail:
29237 return NULL;
29238 }
29239
29240
29241 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29242 PyObject *resultobj = 0;
29243 wxDateSpan result;
29244
29245 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29246 {
29247 PyThreadState* __tstate = wxPyBeginAllowThreads();
29248 result = wxDateSpan::Week();
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29253 return resultobj;
29254 fail:
29255 return NULL;
29256 }
29257
29258
29259 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29260 PyObject *resultobj = 0;
29261 int arg1 ;
29262 wxDateSpan result;
29263 int val1 ;
29264 int ecode1 = 0 ;
29265 PyObject * obj0 = 0 ;
29266 char * kwnames[] = {
29267 (char *) "mon", NULL
29268 };
29269
29270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29271 ecode1 = SWIG_AsVal_int(obj0, &val1);
29272 if (!SWIG_IsOK(ecode1)) {
29273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29274 }
29275 arg1 = static_cast< int >(val1);
29276 {
29277 PyThreadState* __tstate = wxPyBeginAllowThreads();
29278 result = wxDateSpan::Months(arg1);
29279 wxPyEndAllowThreads(__tstate);
29280 if (PyErr_Occurred()) SWIG_fail;
29281 }
29282 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29283 return resultobj;
29284 fail:
29285 return NULL;
29286 }
29287
29288
29289 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29290 PyObject *resultobj = 0;
29291 wxDateSpan result;
29292
29293 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29294 {
29295 PyThreadState* __tstate = wxPyBeginAllowThreads();
29296 result = wxDateSpan::Month();
29297 wxPyEndAllowThreads(__tstate);
29298 if (PyErr_Occurred()) SWIG_fail;
29299 }
29300 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29301 return resultobj;
29302 fail:
29303 return NULL;
29304 }
29305
29306
29307 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29308 PyObject *resultobj = 0;
29309 int arg1 ;
29310 wxDateSpan result;
29311 int val1 ;
29312 int ecode1 = 0 ;
29313 PyObject * obj0 = 0 ;
29314 char * kwnames[] = {
29315 (char *) "years", NULL
29316 };
29317
29318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29319 ecode1 = SWIG_AsVal_int(obj0, &val1);
29320 if (!SWIG_IsOK(ecode1)) {
29321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29322 }
29323 arg1 = static_cast< int >(val1);
29324 {
29325 PyThreadState* __tstate = wxPyBeginAllowThreads();
29326 result = wxDateSpan::Years(arg1);
29327 wxPyEndAllowThreads(__tstate);
29328 if (PyErr_Occurred()) SWIG_fail;
29329 }
29330 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29331 return resultobj;
29332 fail:
29333 return NULL;
29334 }
29335
29336
29337 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29338 PyObject *resultobj = 0;
29339 wxDateSpan result;
29340
29341 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29342 {
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 result = wxDateSpan::Year();
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29356 PyObject *resultobj = 0;
29357 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29358 int arg2 ;
29359 wxDateSpan *result = 0 ;
29360 void *argp1 = 0 ;
29361 int res1 = 0 ;
29362 int val2 ;
29363 int ecode2 = 0 ;
29364 PyObject * obj0 = 0 ;
29365 PyObject * obj1 = 0 ;
29366 char * kwnames[] = {
29367 (char *) "self",(char *) "n", NULL
29368 };
29369
29370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29372 if (!SWIG_IsOK(res1)) {
29373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29374 }
29375 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29376 ecode2 = SWIG_AsVal_int(obj1, &val2);
29377 if (!SWIG_IsOK(ecode2)) {
29378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29379 }
29380 arg2 = static_cast< int >(val2);
29381 {
29382 PyThreadState* __tstate = wxPyBeginAllowThreads();
29383 {
29384 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29385 result = (wxDateSpan *) &_result_ref;
29386 }
29387 wxPyEndAllowThreads(__tstate);
29388 if (PyErr_Occurred()) SWIG_fail;
29389 }
29390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29391 return resultobj;
29392 fail:
29393 return NULL;
29394 }
29395
29396
29397 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29398 PyObject *resultobj = 0;
29399 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29400 int arg2 ;
29401 wxDateSpan *result = 0 ;
29402 void *argp1 = 0 ;
29403 int res1 = 0 ;
29404 int val2 ;
29405 int ecode2 = 0 ;
29406 PyObject * obj0 = 0 ;
29407 PyObject * obj1 = 0 ;
29408 char * kwnames[] = {
29409 (char *) "self",(char *) "n", NULL
29410 };
29411
29412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29414 if (!SWIG_IsOK(res1)) {
29415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29416 }
29417 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29418 ecode2 = SWIG_AsVal_int(obj1, &val2);
29419 if (!SWIG_IsOK(ecode2)) {
29420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29421 }
29422 arg2 = static_cast< int >(val2);
29423 {
29424 PyThreadState* __tstate = wxPyBeginAllowThreads();
29425 {
29426 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29427 result = (wxDateSpan *) &_result_ref;
29428 }
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29433 return resultobj;
29434 fail:
29435 return NULL;
29436 }
29437
29438
29439 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29440 PyObject *resultobj = 0;
29441 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29442 int arg2 ;
29443 wxDateSpan *result = 0 ;
29444 void *argp1 = 0 ;
29445 int res1 = 0 ;
29446 int val2 ;
29447 int ecode2 = 0 ;
29448 PyObject * obj0 = 0 ;
29449 PyObject * obj1 = 0 ;
29450 char * kwnames[] = {
29451 (char *) "self",(char *) "n", NULL
29452 };
29453
29454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29456 if (!SWIG_IsOK(res1)) {
29457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29458 }
29459 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29460 ecode2 = SWIG_AsVal_int(obj1, &val2);
29461 if (!SWIG_IsOK(ecode2)) {
29462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29463 }
29464 arg2 = static_cast< int >(val2);
29465 {
29466 PyThreadState* __tstate = wxPyBeginAllowThreads();
29467 {
29468 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29469 result = (wxDateSpan *) &_result_ref;
29470 }
29471 wxPyEndAllowThreads(__tstate);
29472 if (PyErr_Occurred()) SWIG_fail;
29473 }
29474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29475 return resultobj;
29476 fail:
29477 return NULL;
29478 }
29479
29480
29481 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29482 PyObject *resultobj = 0;
29483 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29484 int arg2 ;
29485 wxDateSpan *result = 0 ;
29486 void *argp1 = 0 ;
29487 int res1 = 0 ;
29488 int val2 ;
29489 int ecode2 = 0 ;
29490 PyObject * obj0 = 0 ;
29491 PyObject * obj1 = 0 ;
29492 char * kwnames[] = {
29493 (char *) "self",(char *) "n", NULL
29494 };
29495
29496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29498 if (!SWIG_IsOK(res1)) {
29499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29500 }
29501 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29502 ecode2 = SWIG_AsVal_int(obj1, &val2);
29503 if (!SWIG_IsOK(ecode2)) {
29504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29505 }
29506 arg2 = static_cast< int >(val2);
29507 {
29508 PyThreadState* __tstate = wxPyBeginAllowThreads();
29509 {
29510 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29511 result = (wxDateSpan *) &_result_ref;
29512 }
29513 wxPyEndAllowThreads(__tstate);
29514 if (PyErr_Occurred()) SWIG_fail;
29515 }
29516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29517 return resultobj;
29518 fail:
29519 return NULL;
29520 }
29521
29522
29523 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29524 PyObject *resultobj = 0;
29525 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29526 int result;
29527 void *argp1 = 0 ;
29528 int res1 = 0 ;
29529 PyObject *swig_obj[1] ;
29530
29531 if (!args) SWIG_fail;
29532 swig_obj[0] = args;
29533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29534 if (!SWIG_IsOK(res1)) {
29535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29536 }
29537 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29538 {
29539 PyThreadState* __tstate = wxPyBeginAllowThreads();
29540 result = (int)((wxDateSpan const *)arg1)->GetYears();
29541 wxPyEndAllowThreads(__tstate);
29542 if (PyErr_Occurred()) SWIG_fail;
29543 }
29544 resultobj = SWIG_From_int(static_cast< int >(result));
29545 return resultobj;
29546 fail:
29547 return NULL;
29548 }
29549
29550
29551 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29552 PyObject *resultobj = 0;
29553 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29554 int result;
29555 void *argp1 = 0 ;
29556 int res1 = 0 ;
29557 PyObject *swig_obj[1] ;
29558
29559 if (!args) SWIG_fail;
29560 swig_obj[0] = args;
29561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29562 if (!SWIG_IsOK(res1)) {
29563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29564 }
29565 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29566 {
29567 PyThreadState* __tstate = wxPyBeginAllowThreads();
29568 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29569 wxPyEndAllowThreads(__tstate);
29570 if (PyErr_Occurred()) SWIG_fail;
29571 }
29572 resultobj = SWIG_From_int(static_cast< int >(result));
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29580 PyObject *resultobj = 0;
29581 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29582 int result;
29583 void *argp1 = 0 ;
29584 int res1 = 0 ;
29585 PyObject *swig_obj[1] ;
29586
29587 if (!args) SWIG_fail;
29588 swig_obj[0] = args;
29589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29590 if (!SWIG_IsOK(res1)) {
29591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29592 }
29593 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29594 {
29595 PyThreadState* __tstate = wxPyBeginAllowThreads();
29596 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29597 wxPyEndAllowThreads(__tstate);
29598 if (PyErr_Occurred()) SWIG_fail;
29599 }
29600 resultobj = SWIG_From_int(static_cast< int >(result));
29601 return resultobj;
29602 fail:
29603 return NULL;
29604 }
29605
29606
29607 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29608 PyObject *resultobj = 0;
29609 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29610 int result;
29611 void *argp1 = 0 ;
29612 int res1 = 0 ;
29613 PyObject *swig_obj[1] ;
29614
29615 if (!args) SWIG_fail;
29616 swig_obj[0] = args;
29617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29618 if (!SWIG_IsOK(res1)) {
29619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29620 }
29621 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 result = (int)((wxDateSpan const *)arg1)->GetDays();
29625 wxPyEndAllowThreads(__tstate);
29626 if (PyErr_Occurred()) SWIG_fail;
29627 }
29628 resultobj = SWIG_From_int(static_cast< int >(result));
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29636 PyObject *resultobj = 0;
29637 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29638 int result;
29639 void *argp1 = 0 ;
29640 int res1 = 0 ;
29641 PyObject *swig_obj[1] ;
29642
29643 if (!args) SWIG_fail;
29644 swig_obj[0] = args;
29645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29648 }
29649 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29650 {
29651 PyThreadState* __tstate = wxPyBeginAllowThreads();
29652 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 resultobj = SWIG_From_int(static_cast< int >(result));
29657 return resultobj;
29658 fail:
29659 return NULL;
29660 }
29661
29662
29663 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29664 PyObject *resultobj = 0;
29665 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29666 wxDateSpan *arg2 = 0 ;
29667 wxDateSpan *result = 0 ;
29668 void *argp1 = 0 ;
29669 int res1 = 0 ;
29670 void *argp2 = 0 ;
29671 int res2 = 0 ;
29672 PyObject * obj0 = 0 ;
29673 PyObject * obj1 = 0 ;
29674 char * kwnames[] = {
29675 (char *) "self",(char *) "other", NULL
29676 };
29677
29678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29680 if (!SWIG_IsOK(res1)) {
29681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29682 }
29683 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29684 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29685 if (!SWIG_IsOK(res2)) {
29686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29687 }
29688 if (!argp2) {
29689 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29690 }
29691 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29692 {
29693 PyThreadState* __tstate = wxPyBeginAllowThreads();
29694 {
29695 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29696 result = (wxDateSpan *) &_result_ref;
29697 }
29698 wxPyEndAllowThreads(__tstate);
29699 if (PyErr_Occurred()) SWIG_fail;
29700 }
29701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29702 return resultobj;
29703 fail:
29704 return NULL;
29705 }
29706
29707
29708 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29709 PyObject *resultobj = 0;
29710 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29711 wxDateSpan *arg2 = 0 ;
29712 wxDateSpan *result = 0 ;
29713 void *argp1 = 0 ;
29714 int res1 = 0 ;
29715 void *argp2 = 0 ;
29716 int res2 = 0 ;
29717 PyObject * obj0 = 0 ;
29718 PyObject * obj1 = 0 ;
29719 char * kwnames[] = {
29720 (char *) "self",(char *) "other", NULL
29721 };
29722
29723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29725 if (!SWIG_IsOK(res1)) {
29726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29727 }
29728 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29729 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29730 if (!SWIG_IsOK(res2)) {
29731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29732 }
29733 if (!argp2) {
29734 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29735 }
29736 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29737 {
29738 PyThreadState* __tstate = wxPyBeginAllowThreads();
29739 {
29740 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29741 result = (wxDateSpan *) &_result_ref;
29742 }
29743 wxPyEndAllowThreads(__tstate);
29744 if (PyErr_Occurred()) SWIG_fail;
29745 }
29746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29747 return resultobj;
29748 fail:
29749 return NULL;
29750 }
29751
29752
29753 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29754 PyObject *resultobj = 0;
29755 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29756 wxDateSpan *result = 0 ;
29757 void *argp1 = 0 ;
29758 int res1 = 0 ;
29759 PyObject *swig_obj[1] ;
29760
29761 if (!args) SWIG_fail;
29762 swig_obj[0] = args;
29763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29764 if (!SWIG_IsOK(res1)) {
29765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29766 }
29767 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29768 {
29769 PyThreadState* __tstate = wxPyBeginAllowThreads();
29770 {
29771 wxDateSpan &_result_ref = (arg1)->Neg();
29772 result = (wxDateSpan *) &_result_ref;
29773 }
29774 wxPyEndAllowThreads(__tstate);
29775 if (PyErr_Occurred()) SWIG_fail;
29776 }
29777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29778 return resultobj;
29779 fail:
29780 return NULL;
29781 }
29782
29783
29784 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29785 PyObject *resultobj = 0;
29786 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29787 int arg2 ;
29788 wxDateSpan *result = 0 ;
29789 void *argp1 = 0 ;
29790 int res1 = 0 ;
29791 int val2 ;
29792 int ecode2 = 0 ;
29793 PyObject * obj0 = 0 ;
29794 PyObject * obj1 = 0 ;
29795 char * kwnames[] = {
29796 (char *) "self",(char *) "factor", NULL
29797 };
29798
29799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29801 if (!SWIG_IsOK(res1)) {
29802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29803 }
29804 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29805 ecode2 = SWIG_AsVal_int(obj1, &val2);
29806 if (!SWIG_IsOK(ecode2)) {
29807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29808 }
29809 arg2 = static_cast< int >(val2);
29810 {
29811 PyThreadState* __tstate = wxPyBeginAllowThreads();
29812 {
29813 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29814 result = (wxDateSpan *) &_result_ref;
29815 }
29816 wxPyEndAllowThreads(__tstate);
29817 if (PyErr_Occurred()) SWIG_fail;
29818 }
29819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29820 return resultobj;
29821 fail:
29822 return NULL;
29823 }
29824
29825
29826 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29827 PyObject *resultobj = 0;
29828 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29829 wxDateSpan *arg2 = 0 ;
29830 wxDateSpan *result = 0 ;
29831 void *argp1 = 0 ;
29832 int res1 = 0 ;
29833 void *argp2 = 0 ;
29834 int res2 = 0 ;
29835 PyObject * obj0 = 0 ;
29836 PyObject * obj1 = 0 ;
29837 char * kwnames[] = {
29838 (char *) "self",(char *) "other", NULL
29839 };
29840
29841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29843 if (!SWIG_IsOK(res1)) {
29844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29845 }
29846 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29847 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29848 if (!SWIG_IsOK(res2)) {
29849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29850 }
29851 if (!argp2) {
29852 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29853 }
29854 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29855 {
29856 PyThreadState* __tstate = wxPyBeginAllowThreads();
29857 {
29858 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29859 result = (wxDateSpan *) &_result_ref;
29860 }
29861 wxPyEndAllowThreads(__tstate);
29862 if (PyErr_Occurred()) SWIG_fail;
29863 }
29864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29865 return resultobj;
29866 fail:
29867 return NULL;
29868 }
29869
29870
29871 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29872 PyObject *resultobj = 0;
29873 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29874 wxDateSpan *arg2 = 0 ;
29875 wxDateSpan *result = 0 ;
29876 void *argp1 = 0 ;
29877 int res1 = 0 ;
29878 void *argp2 = 0 ;
29879 int res2 = 0 ;
29880 PyObject * obj0 = 0 ;
29881 PyObject * obj1 = 0 ;
29882 char * kwnames[] = {
29883 (char *) "self",(char *) "other", NULL
29884 };
29885
29886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29888 if (!SWIG_IsOK(res1)) {
29889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29890 }
29891 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29892 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29893 if (!SWIG_IsOK(res2)) {
29894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29895 }
29896 if (!argp2) {
29897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29898 }
29899 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29900 {
29901 PyThreadState* __tstate = wxPyBeginAllowThreads();
29902 {
29903 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29904 result = (wxDateSpan *) &_result_ref;
29905 }
29906 wxPyEndAllowThreads(__tstate);
29907 if (PyErr_Occurred()) SWIG_fail;
29908 }
29909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29910 return resultobj;
29911 fail:
29912 return NULL;
29913 }
29914
29915
29916 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29917 PyObject *resultobj = 0;
29918 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29919 wxDateSpan *result = 0 ;
29920 void *argp1 = 0 ;
29921 int res1 = 0 ;
29922 PyObject *swig_obj[1] ;
29923
29924 if (!args) SWIG_fail;
29925 swig_obj[0] = args;
29926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29927 if (!SWIG_IsOK(res1)) {
29928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29929 }
29930 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29931 {
29932 PyThreadState* __tstate = wxPyBeginAllowThreads();
29933 {
29934 wxDateSpan &_result_ref = (arg1)->operator -();
29935 result = (wxDateSpan *) &_result_ref;
29936 }
29937 wxPyEndAllowThreads(__tstate);
29938 if (PyErr_Occurred()) SWIG_fail;
29939 }
29940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29941 return resultobj;
29942 fail:
29943 return NULL;
29944 }
29945
29946
29947 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29948 PyObject *resultobj = 0;
29949 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29950 int arg2 ;
29951 wxDateSpan *result = 0 ;
29952 void *argp1 = 0 ;
29953 int res1 = 0 ;
29954 int val2 ;
29955 int ecode2 = 0 ;
29956 PyObject * obj0 = 0 ;
29957 PyObject * obj1 = 0 ;
29958 char * kwnames[] = {
29959 (char *) "self",(char *) "factor", NULL
29960 };
29961
29962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29964 if (!SWIG_IsOK(res1)) {
29965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29966 }
29967 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29968 ecode2 = SWIG_AsVal_int(obj1, &val2);
29969 if (!SWIG_IsOK(ecode2)) {
29970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29971 }
29972 arg2 = static_cast< int >(val2);
29973 {
29974 PyThreadState* __tstate = wxPyBeginAllowThreads();
29975 {
29976 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29977 result = (wxDateSpan *) &_result_ref;
29978 }
29979 wxPyEndAllowThreads(__tstate);
29980 if (PyErr_Occurred()) SWIG_fail;
29981 }
29982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29983 return resultobj;
29984 fail:
29985 return NULL;
29986 }
29987
29988
29989 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29990 PyObject *resultobj = 0;
29991 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29992 wxDateSpan *arg2 = 0 ;
29993 wxDateSpan result;
29994 void *argp1 = 0 ;
29995 int res1 = 0 ;
29996 void *argp2 = 0 ;
29997 int res2 = 0 ;
29998 PyObject * obj0 = 0 ;
29999 PyObject * obj1 = 0 ;
30000 char * kwnames[] = {
30001 (char *) "self",(char *) "other", NULL
30002 };
30003
30004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
30005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30006 if (!SWIG_IsOK(res1)) {
30007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30008 }
30009 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30010 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30011 if (!SWIG_IsOK(res2)) {
30012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30013 }
30014 if (!argp2) {
30015 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30016 }
30017 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30018 {
30019 PyThreadState* __tstate = wxPyBeginAllowThreads();
30020 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30021 wxPyEndAllowThreads(__tstate);
30022 if (PyErr_Occurred()) SWIG_fail;
30023 }
30024 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30025 return resultobj;
30026 fail:
30027 return NULL;
30028 }
30029
30030
30031 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30032 PyObject *resultobj = 0;
30033 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30034 wxDateSpan *arg2 = 0 ;
30035 wxDateSpan result;
30036 void *argp1 = 0 ;
30037 int res1 = 0 ;
30038 void *argp2 = 0 ;
30039 int res2 = 0 ;
30040 PyObject * obj0 = 0 ;
30041 PyObject * obj1 = 0 ;
30042 char * kwnames[] = {
30043 (char *) "self",(char *) "other", NULL
30044 };
30045
30046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
30047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30048 if (!SWIG_IsOK(res1)) {
30049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30050 }
30051 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30053 if (!SWIG_IsOK(res2)) {
30054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30055 }
30056 if (!argp2) {
30057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30058 }
30059 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30060 {
30061 PyThreadState* __tstate = wxPyBeginAllowThreads();
30062 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
30063 wxPyEndAllowThreads(__tstate);
30064 if (PyErr_Occurred()) SWIG_fail;
30065 }
30066 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30074 PyObject *resultobj = 0;
30075 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30076 int arg2 ;
30077 wxDateSpan result;
30078 void *argp1 = 0 ;
30079 int res1 = 0 ;
30080 int val2 ;
30081 int ecode2 = 0 ;
30082 PyObject * obj0 = 0 ;
30083 PyObject * obj1 = 0 ;
30084 char * kwnames[] = {
30085 (char *) "self",(char *) "n", NULL
30086 };
30087
30088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
30089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30090 if (!SWIG_IsOK(res1)) {
30091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30092 }
30093 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30094 ecode2 = SWIG_AsVal_int(obj1, &val2);
30095 if (!SWIG_IsOK(ecode2)) {
30096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
30097 }
30098 arg2 = static_cast< int >(val2);
30099 {
30100 PyThreadState* __tstate = wxPyBeginAllowThreads();
30101 result = wxDateSpan___mul__(arg1,arg2);
30102 wxPyEndAllowThreads(__tstate);
30103 if (PyErr_Occurred()) SWIG_fail;
30104 }
30105 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30106 return resultobj;
30107 fail:
30108 return NULL;
30109 }
30110
30111
30112 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30113 PyObject *resultobj = 0;
30114 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30115 int arg2 ;
30116 wxDateSpan result;
30117 void *argp1 = 0 ;
30118 int res1 = 0 ;
30119 int val2 ;
30120 int ecode2 = 0 ;
30121 PyObject * obj0 = 0 ;
30122 PyObject * obj1 = 0 ;
30123 char * kwnames[] = {
30124 (char *) "self",(char *) "n", NULL
30125 };
30126
30127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30129 if (!SWIG_IsOK(res1)) {
30130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30131 }
30132 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30133 ecode2 = SWIG_AsVal_int(obj1, &val2);
30134 if (!SWIG_IsOK(ecode2)) {
30135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30136 }
30137 arg2 = static_cast< int >(val2);
30138 {
30139 PyThreadState* __tstate = wxPyBeginAllowThreads();
30140 result = wxDateSpan___rmul__(arg1,arg2);
30141 wxPyEndAllowThreads(__tstate);
30142 if (PyErr_Occurred()) SWIG_fail;
30143 }
30144 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30145 return resultobj;
30146 fail:
30147 return NULL;
30148 }
30149
30150
30151 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30152 PyObject *resultobj = 0;
30153 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30154 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30155 bool result;
30156 void *argp1 = 0 ;
30157 int res1 = 0 ;
30158 void *argp2 = 0 ;
30159 int res2 = 0 ;
30160 PyObject * obj0 = 0 ;
30161 PyObject * obj1 = 0 ;
30162 char * kwnames[] = {
30163 (char *) "self",(char *) "other", NULL
30164 };
30165
30166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30168 if (!SWIG_IsOK(res1)) {
30169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30170 }
30171 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30173 if (!SWIG_IsOK(res2)) {
30174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30175 }
30176 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30177 {
30178 PyThreadState* __tstate = wxPyBeginAllowThreads();
30179 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30180 wxPyEndAllowThreads(__tstate);
30181 if (PyErr_Occurred()) SWIG_fail;
30182 }
30183 {
30184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30185 }
30186 return resultobj;
30187 fail:
30188 return NULL;
30189 }
30190
30191
30192 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30193 PyObject *resultobj = 0;
30194 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30195 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30196 bool result;
30197 void *argp1 = 0 ;
30198 int res1 = 0 ;
30199 void *argp2 = 0 ;
30200 int res2 = 0 ;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 char * kwnames[] = {
30204 (char *) "self",(char *) "other", NULL
30205 };
30206
30207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30209 if (!SWIG_IsOK(res1)) {
30210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30211 }
30212 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30214 if (!SWIG_IsOK(res2)) {
30215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30216 }
30217 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30218 {
30219 PyThreadState* __tstate = wxPyBeginAllowThreads();
30220 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30221 wxPyEndAllowThreads(__tstate);
30222 if (PyErr_Occurred()) SWIG_fail;
30223 }
30224 {
30225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30226 }
30227 return resultobj;
30228 fail:
30229 return NULL;
30230 }
30231
30232
30233 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30234 PyObject *obj;
30235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30236 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30237 return SWIG_Py_Void();
30238 }
30239
30240 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30241 return SWIG_Python_InitShadowInstance(args);
30242 }
30243
30244 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30245 PyObject *resultobj = 0;
30246 long result;
30247
30248 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30249 {
30250 PyThreadState* __tstate = wxPyBeginAllowThreads();
30251 result = (long)wxGetLocalTime();
30252 wxPyEndAllowThreads(__tstate);
30253 if (PyErr_Occurred()) SWIG_fail;
30254 }
30255 resultobj = SWIG_From_long(static_cast< long >(result));
30256 return resultobj;
30257 fail:
30258 return NULL;
30259 }
30260
30261
30262 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30263 PyObject *resultobj = 0;
30264 long result;
30265
30266 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30267 {
30268 PyThreadState* __tstate = wxPyBeginAllowThreads();
30269 result = (long)wxGetUTCTime();
30270 wxPyEndAllowThreads(__tstate);
30271 if (PyErr_Occurred()) SWIG_fail;
30272 }
30273 resultobj = SWIG_From_long(static_cast< long >(result));
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30281 PyObject *resultobj = 0;
30282 long result;
30283
30284 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30285 {
30286 PyThreadState* __tstate = wxPyBeginAllowThreads();
30287 result = (long)wxGetCurrentTime();
30288 wxPyEndAllowThreads(__tstate);
30289 if (PyErr_Occurred()) SWIG_fail;
30290 }
30291 resultobj = SWIG_From_long(static_cast< long >(result));
30292 return resultobj;
30293 fail:
30294 return NULL;
30295 }
30296
30297
30298 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30299 PyObject *resultobj = 0;
30300 wxLongLong result;
30301
30302 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30303 {
30304 PyThreadState* __tstate = wxPyBeginAllowThreads();
30305 result = wxGetLocalTimeMillis();
30306 wxPyEndAllowThreads(__tstate);
30307 if (PyErr_Occurred()) SWIG_fail;
30308 }
30309 {
30310 PyObject *hi, *lo, *shifter, *shifted;
30311 hi = PyLong_FromLong( (&result)->GetHi() );
30312 lo = PyLong_FromLong( (&result)->GetLo() );
30313 shifter = PyLong_FromLong(32);
30314 shifted = PyNumber_Lshift(hi, shifter);
30315 resultobj = PyNumber_Or(shifted, lo);
30316 Py_DECREF(hi);
30317 Py_DECREF(lo);
30318 Py_DECREF(shifter);
30319 Py_DECREF(shifted);
30320 }
30321 return resultobj;
30322 fail:
30323 return NULL;
30324 }
30325
30326
30327 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30328 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30329 return 1;
30330 }
30331
30332
30333 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30334 PyObject *pyobj = 0;
30335
30336 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30337 return pyobj;
30338 }
30339
30340
30341 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30342 PyObject *resultobj = 0;
30343 wxDataFormatId arg1 ;
30344 wxDataFormat *result = 0 ;
30345 int val1 ;
30346 int ecode1 = 0 ;
30347 PyObject * obj0 = 0 ;
30348 char * kwnames[] = {
30349 (char *) "type", NULL
30350 };
30351
30352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30353 ecode1 = SWIG_AsVal_int(obj0, &val1);
30354 if (!SWIG_IsOK(ecode1)) {
30355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30356 }
30357 arg1 = static_cast< wxDataFormatId >(val1);
30358 {
30359 PyThreadState* __tstate = wxPyBeginAllowThreads();
30360 result = (wxDataFormat *)new wxDataFormat(arg1);
30361 wxPyEndAllowThreads(__tstate);
30362 if (PyErr_Occurred()) SWIG_fail;
30363 }
30364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30372 PyObject *resultobj = 0;
30373 wxString *arg1 = 0 ;
30374 wxDataFormat *result = 0 ;
30375 bool temp1 = false ;
30376 PyObject * obj0 = 0 ;
30377 char * kwnames[] = {
30378 (char *) "format", NULL
30379 };
30380
30381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30382 {
30383 arg1 = wxString_in_helper(obj0);
30384 if (arg1 == NULL) SWIG_fail;
30385 temp1 = true;
30386 }
30387 {
30388 PyThreadState* __tstate = wxPyBeginAllowThreads();
30389 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30390 wxPyEndAllowThreads(__tstate);
30391 if (PyErr_Occurred()) SWIG_fail;
30392 }
30393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30394 {
30395 if (temp1)
30396 delete arg1;
30397 }
30398 return resultobj;
30399 fail:
30400 {
30401 if (temp1)
30402 delete arg1;
30403 }
30404 return NULL;
30405 }
30406
30407
30408 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30409 PyObject *resultobj = 0;
30410 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30411 void *argp1 = 0 ;
30412 int res1 = 0 ;
30413 PyObject *swig_obj[1] ;
30414
30415 if (!args) SWIG_fail;
30416 swig_obj[0] = args;
30417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30418 if (!SWIG_IsOK(res1)) {
30419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30420 }
30421 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30422 {
30423 PyThreadState* __tstate = wxPyBeginAllowThreads();
30424 delete arg1;
30425
30426 wxPyEndAllowThreads(__tstate);
30427 if (PyErr_Occurred()) SWIG_fail;
30428 }
30429 resultobj = SWIG_Py_Void();
30430 return resultobj;
30431 fail:
30432 return NULL;
30433 }
30434
30435
30436 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30437 PyObject *resultobj = 0;
30438 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30439 wxDataFormatId arg2 ;
30440 bool result;
30441 void *argp1 = 0 ;
30442 int res1 = 0 ;
30443 int val2 ;
30444 int ecode2 = 0 ;
30445
30446 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30448 if (!SWIG_IsOK(res1)) {
30449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30450 }
30451 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30452 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30453 if (!SWIG_IsOK(ecode2)) {
30454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30455 }
30456 arg2 = static_cast< wxDataFormatId >(val2);
30457 {
30458 PyThreadState* __tstate = wxPyBeginAllowThreads();
30459 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30460 wxPyEndAllowThreads(__tstate);
30461 if (PyErr_Occurred()) SWIG_fail;
30462 }
30463 {
30464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30465 }
30466 return resultobj;
30467 fail:
30468 return NULL;
30469 }
30470
30471
30472 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30473 PyObject *resultobj = 0;
30474 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30475 wxDataFormatId arg2 ;
30476 bool result;
30477 void *argp1 = 0 ;
30478 int res1 = 0 ;
30479 int val2 ;
30480 int ecode2 = 0 ;
30481
30482 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30484 if (!SWIG_IsOK(res1)) {
30485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30486 }
30487 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30488 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30489 if (!SWIG_IsOK(ecode2)) {
30490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30491 }
30492 arg2 = static_cast< wxDataFormatId >(val2);
30493 {
30494 PyThreadState* __tstate = wxPyBeginAllowThreads();
30495 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30496 wxPyEndAllowThreads(__tstate);
30497 if (PyErr_Occurred()) SWIG_fail;
30498 }
30499 {
30500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30501 }
30502 return resultobj;
30503 fail:
30504 return NULL;
30505 }
30506
30507
30508 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30509 PyObject *resultobj = 0;
30510 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30511 wxDataFormat *arg2 = 0 ;
30512 bool result;
30513 void *argp1 = 0 ;
30514 int res1 = 0 ;
30515 void *argp2 = 0 ;
30516 int res2 = 0 ;
30517
30518 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30520 if (!SWIG_IsOK(res1)) {
30521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30522 }
30523 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30524 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30525 if (!SWIG_IsOK(res2)) {
30526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30527 }
30528 if (!argp2) {
30529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30530 }
30531 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30532 {
30533 PyThreadState* __tstate = wxPyBeginAllowThreads();
30534 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30535 wxPyEndAllowThreads(__tstate);
30536 if (PyErr_Occurred()) SWIG_fail;
30537 }
30538 {
30539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30540 }
30541 return resultobj;
30542 fail:
30543 return NULL;
30544 }
30545
30546
30547 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30548 int argc;
30549 PyObject *argv[3];
30550
30551 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30552 --argc;
30553 if (argc == 2) {
30554 int _v = 0;
30555 {
30556 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30557 _v = SWIG_CheckState(res);
30558 }
30559 if (!_v) goto check_1;
30560 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30561 }
30562 check_1:
30563
30564 if (argc == 2) {
30565 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30566 }
30567
30568 fail:
30569 Py_INCREF(Py_NotImplemented);
30570 return Py_NotImplemented;
30571 }
30572
30573
30574 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30575 PyObject *resultobj = 0;
30576 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30577 wxDataFormat *arg2 = 0 ;
30578 bool result;
30579 void *argp1 = 0 ;
30580 int res1 = 0 ;
30581 void *argp2 = 0 ;
30582 int res2 = 0 ;
30583
30584 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30586 if (!SWIG_IsOK(res1)) {
30587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30588 }
30589 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30590 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30591 if (!SWIG_IsOK(res2)) {
30592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30593 }
30594 if (!argp2) {
30595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30596 }
30597 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30598 {
30599 PyThreadState* __tstate = wxPyBeginAllowThreads();
30600 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30601 wxPyEndAllowThreads(__tstate);
30602 if (PyErr_Occurred()) SWIG_fail;
30603 }
30604 {
30605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30606 }
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30614 int argc;
30615 PyObject *argv[3];
30616
30617 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30618 --argc;
30619 if (argc == 2) {
30620 int _v = 0;
30621 {
30622 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30623 _v = SWIG_CheckState(res);
30624 }
30625 if (!_v) goto check_1;
30626 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30627 }
30628 check_1:
30629
30630 if (argc == 2) {
30631 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30632 }
30633
30634 fail:
30635 Py_INCREF(Py_NotImplemented);
30636 return Py_NotImplemented;
30637 }
30638
30639
30640 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30641 PyObject *resultobj = 0;
30642 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30643 wxDataFormatId arg2 ;
30644 void *argp1 = 0 ;
30645 int res1 = 0 ;
30646 int val2 ;
30647 int ecode2 = 0 ;
30648 PyObject * obj0 = 0 ;
30649 PyObject * obj1 = 0 ;
30650 char * kwnames[] = {
30651 (char *) "self",(char *) "format", NULL
30652 };
30653
30654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30656 if (!SWIG_IsOK(res1)) {
30657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30658 }
30659 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30660 ecode2 = SWIG_AsVal_int(obj1, &val2);
30661 if (!SWIG_IsOK(ecode2)) {
30662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30663 }
30664 arg2 = static_cast< wxDataFormatId >(val2);
30665 {
30666 PyThreadState* __tstate = wxPyBeginAllowThreads();
30667 (arg1)->SetType(arg2);
30668 wxPyEndAllowThreads(__tstate);
30669 if (PyErr_Occurred()) SWIG_fail;
30670 }
30671 resultobj = SWIG_Py_Void();
30672 return resultobj;
30673 fail:
30674 return NULL;
30675 }
30676
30677
30678 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30679 PyObject *resultobj = 0;
30680 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30681 wxDataFormatId result;
30682 void *argp1 = 0 ;
30683 int res1 = 0 ;
30684 PyObject *swig_obj[1] ;
30685
30686 if (!args) SWIG_fail;
30687 swig_obj[0] = args;
30688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30689 if (!SWIG_IsOK(res1)) {
30690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30691 }
30692 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30696 wxPyEndAllowThreads(__tstate);
30697 if (PyErr_Occurred()) SWIG_fail;
30698 }
30699 resultobj = SWIG_From_int(static_cast< int >(result));
30700 return resultobj;
30701 fail:
30702 return NULL;
30703 }
30704
30705
30706 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30707 PyObject *resultobj = 0;
30708 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30709 wxString result;
30710 void *argp1 = 0 ;
30711 int res1 = 0 ;
30712 PyObject *swig_obj[1] ;
30713
30714 if (!args) SWIG_fail;
30715 swig_obj[0] = args;
30716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30717 if (!SWIG_IsOK(res1)) {
30718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30719 }
30720 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = ((wxDataFormat const *)arg1)->GetId();
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 {
30728 #if wxUSE_UNICODE
30729 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30730 #else
30731 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30732 #endif
30733 }
30734 return resultobj;
30735 fail:
30736 return NULL;
30737 }
30738
30739
30740 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30741 PyObject *resultobj = 0;
30742 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30743 wxString *arg2 = 0 ;
30744 void *argp1 = 0 ;
30745 int res1 = 0 ;
30746 bool temp2 = false ;
30747 PyObject * obj0 = 0 ;
30748 PyObject * obj1 = 0 ;
30749 char * kwnames[] = {
30750 (char *) "self",(char *) "format", NULL
30751 };
30752
30753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30755 if (!SWIG_IsOK(res1)) {
30756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30757 }
30758 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30759 {
30760 arg2 = wxString_in_helper(obj1);
30761 if (arg2 == NULL) SWIG_fail;
30762 temp2 = true;
30763 }
30764 {
30765 PyThreadState* __tstate = wxPyBeginAllowThreads();
30766 (arg1)->SetId((wxString const &)*arg2);
30767 wxPyEndAllowThreads(__tstate);
30768 if (PyErr_Occurred()) SWIG_fail;
30769 }
30770 resultobj = SWIG_Py_Void();
30771 {
30772 if (temp2)
30773 delete arg2;
30774 }
30775 return resultobj;
30776 fail:
30777 {
30778 if (temp2)
30779 delete arg2;
30780 }
30781 return NULL;
30782 }
30783
30784
30785 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30786 PyObject *obj;
30787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30788 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30789 return SWIG_Py_Void();
30790 }
30791
30792 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30793 return SWIG_Python_InitShadowInstance(args);
30794 }
30795
30796 SWIGINTERN int FormatInvalid_set(PyObject *) {
30797 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30798 return 1;
30799 }
30800
30801
30802 SWIGINTERN PyObject *FormatInvalid_get(void) {
30803 PyObject *pyobj = 0;
30804
30805 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30806 return pyobj;
30807 }
30808
30809
30810 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30811 PyObject *resultobj = 0;
30812 wxDataObject *arg1 = (wxDataObject *) 0 ;
30813 void *argp1 = 0 ;
30814 int res1 = 0 ;
30815 PyObject *swig_obj[1] ;
30816
30817 if (!args) SWIG_fail;
30818 swig_obj[0] = args;
30819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30820 if (!SWIG_IsOK(res1)) {
30821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30822 }
30823 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 delete arg1;
30827
30828 wxPyEndAllowThreads(__tstate);
30829 if (PyErr_Occurred()) SWIG_fail;
30830 }
30831 resultobj = SWIG_Py_Void();
30832 return resultobj;
30833 fail:
30834 return NULL;
30835 }
30836
30837
30838 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30839 PyObject *resultobj = 0;
30840 wxDataObject *arg1 = (wxDataObject *) 0 ;
30841 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30842 SwigValueWrapper<wxDataFormat > result;
30843 void *argp1 = 0 ;
30844 int res1 = 0 ;
30845 int val2 ;
30846 int ecode2 = 0 ;
30847 PyObject * obj0 = 0 ;
30848 PyObject * obj1 = 0 ;
30849 char * kwnames[] = {
30850 (char *) "self",(char *) "dir", NULL
30851 };
30852
30853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30855 if (!SWIG_IsOK(res1)) {
30856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30857 }
30858 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30859 if (obj1) {
30860 ecode2 = SWIG_AsVal_int(obj1, &val2);
30861 if (!SWIG_IsOK(ecode2)) {
30862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30863 }
30864 arg2 = static_cast< wxDataObject::Direction >(val2);
30865 }
30866 {
30867 PyThreadState* __tstate = wxPyBeginAllowThreads();
30868 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30869 wxPyEndAllowThreads(__tstate);
30870 if (PyErr_Occurred()) SWIG_fail;
30871 }
30872 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30873 return resultobj;
30874 fail:
30875 return NULL;
30876 }
30877
30878
30879 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30880 PyObject *resultobj = 0;
30881 wxDataObject *arg1 = (wxDataObject *) 0 ;
30882 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30883 size_t result;
30884 void *argp1 = 0 ;
30885 int res1 = 0 ;
30886 int val2 ;
30887 int ecode2 = 0 ;
30888 PyObject * obj0 = 0 ;
30889 PyObject * obj1 = 0 ;
30890 char * kwnames[] = {
30891 (char *) "self",(char *) "dir", NULL
30892 };
30893
30894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30896 if (!SWIG_IsOK(res1)) {
30897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30898 }
30899 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30900 if (obj1) {
30901 ecode2 = SWIG_AsVal_int(obj1, &val2);
30902 if (!SWIG_IsOK(ecode2)) {
30903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30904 }
30905 arg2 = static_cast< wxDataObject::Direction >(val2);
30906 }
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30910 wxPyEndAllowThreads(__tstate);
30911 if (PyErr_Occurred()) SWIG_fail;
30912 }
30913 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30921 PyObject *resultobj = 0;
30922 wxDataObject *arg1 = (wxDataObject *) 0 ;
30923 wxDataFormat *arg2 = 0 ;
30924 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30925 bool result;
30926 void *argp1 = 0 ;
30927 int res1 = 0 ;
30928 void *argp2 = 0 ;
30929 int res2 = 0 ;
30930 int val3 ;
30931 int ecode3 = 0 ;
30932 PyObject * obj0 = 0 ;
30933 PyObject * obj1 = 0 ;
30934 PyObject * obj2 = 0 ;
30935 char * kwnames[] = {
30936 (char *) "self",(char *) "format",(char *) "dir", NULL
30937 };
30938
30939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30941 if (!SWIG_IsOK(res1)) {
30942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30943 }
30944 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30946 if (!SWIG_IsOK(res2)) {
30947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30948 }
30949 if (!argp2) {
30950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30951 }
30952 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30953 if (obj2) {
30954 ecode3 = SWIG_AsVal_int(obj2, &val3);
30955 if (!SWIG_IsOK(ecode3)) {
30956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30957 }
30958 arg3 = static_cast< wxDataObject::Direction >(val3);
30959 }
30960 {
30961 PyThreadState* __tstate = wxPyBeginAllowThreads();
30962 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 {
30967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30968 }
30969 return resultobj;
30970 fail:
30971 return NULL;
30972 }
30973
30974
30975 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30976 PyObject *resultobj = 0;
30977 wxDataObject *arg1 = (wxDataObject *) 0 ;
30978 wxDataFormat *arg2 = 0 ;
30979 size_t result;
30980 void *argp1 = 0 ;
30981 int res1 = 0 ;
30982 void *argp2 = 0 ;
30983 int res2 = 0 ;
30984 PyObject * obj0 = 0 ;
30985 PyObject * obj1 = 0 ;
30986 char * kwnames[] = {
30987 (char *) "self",(char *) "format", NULL
30988 };
30989
30990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30992 if (!SWIG_IsOK(res1)) {
30993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30994 }
30995 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30996 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30997 if (!SWIG_IsOK(res2)) {
30998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30999 }
31000 if (!argp2) {
31001 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31002 }
31003 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31011 return resultobj;
31012 fail:
31013 return NULL;
31014 }
31015
31016
31017 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31018 PyObject *resultobj = 0;
31019 wxDataObject *arg1 = (wxDataObject *) 0 ;
31020 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31021 PyObject *result = 0 ;
31022 void *argp1 = 0 ;
31023 int res1 = 0 ;
31024 int val2 ;
31025 int ecode2 = 0 ;
31026 PyObject * obj0 = 0 ;
31027 PyObject * obj1 = 0 ;
31028 char * kwnames[] = {
31029 (char *) "self",(char *) "dir", NULL
31030 };
31031
31032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
31033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31034 if (!SWIG_IsOK(res1)) {
31035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
31036 }
31037 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31038 if (obj1) {
31039 ecode2 = SWIG_AsVal_int(obj1, &val2);
31040 if (!SWIG_IsOK(ecode2)) {
31041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31042 }
31043 arg2 = static_cast< wxDataObject::Direction >(val2);
31044 }
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 resultobj = result;
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31059 PyObject *resultobj = 0;
31060 wxDataObject *arg1 = (wxDataObject *) 0 ;
31061 wxDataFormat *arg2 = 0 ;
31062 PyObject *result = 0 ;
31063 void *argp1 = 0 ;
31064 int res1 = 0 ;
31065 void *argp2 = 0 ;
31066 int res2 = 0 ;
31067 PyObject * obj0 = 0 ;
31068 PyObject * obj1 = 0 ;
31069 char * kwnames[] = {
31070 (char *) "self",(char *) "format", NULL
31071 };
31072
31073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
31074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31075 if (!SWIG_IsOK(res1)) {
31076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
31077 }
31078 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31079 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31080 if (!SWIG_IsOK(res2)) {
31081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31082 }
31083 if (!argp2) {
31084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31085 }
31086 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31087 {
31088 PyThreadState* __tstate = wxPyBeginAllowThreads();
31089 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
31090 wxPyEndAllowThreads(__tstate);
31091 if (PyErr_Occurred()) SWIG_fail;
31092 }
31093 resultobj = result;
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31101 PyObject *resultobj = 0;
31102 wxDataObject *arg1 = (wxDataObject *) 0 ;
31103 wxDataFormat *arg2 = 0 ;
31104 PyObject *arg3 = (PyObject *) 0 ;
31105 bool result;
31106 void *argp1 = 0 ;
31107 int res1 = 0 ;
31108 void *argp2 = 0 ;
31109 int res2 = 0 ;
31110 PyObject * obj0 = 0 ;
31111 PyObject * obj1 = 0 ;
31112 PyObject * obj2 = 0 ;
31113 char * kwnames[] = {
31114 (char *) "self",(char *) "format",(char *) "data", NULL
31115 };
31116
31117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31119 if (!SWIG_IsOK(res1)) {
31120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
31121 }
31122 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31123 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31124 if (!SWIG_IsOK(res2)) {
31125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31126 }
31127 if (!argp2) {
31128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31129 }
31130 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31131 arg3 = obj2;
31132 {
31133 PyThreadState* __tstate = wxPyBeginAllowThreads();
31134 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31135 wxPyEndAllowThreads(__tstate);
31136 if (PyErr_Occurred()) SWIG_fail;
31137 }
31138 {
31139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31140 }
31141 return resultobj;
31142 fail:
31143 return NULL;
31144 }
31145
31146
31147 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31148 PyObject *obj;
31149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31150 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31151 return SWIG_Py_Void();
31152 }
31153
31154 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31155 PyObject *resultobj = 0;
31156 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31157 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31158 wxDataObjectSimple *result = 0 ;
31159 void *argp1 = 0 ;
31160 int res1 = 0 ;
31161 PyObject * obj0 = 0 ;
31162 char * kwnames[] = {
31163 (char *) "format", NULL
31164 };
31165
31166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31167 if (obj0) {
31168 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31169 if (!SWIG_IsOK(res1)) {
31170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31171 }
31172 if (!argp1) {
31173 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31174 }
31175 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31176 }
31177 {
31178 PyThreadState* __tstate = wxPyBeginAllowThreads();
31179 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31180 wxPyEndAllowThreads(__tstate);
31181 if (PyErr_Occurred()) SWIG_fail;
31182 }
31183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31184 return resultobj;
31185 fail:
31186 return NULL;
31187 }
31188
31189
31190 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31191 PyObject *resultobj = 0;
31192 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31193 wxDataFormat *result = 0 ;
31194 void *argp1 = 0 ;
31195 int res1 = 0 ;
31196 PyObject *swig_obj[1] ;
31197
31198 if (!args) SWIG_fail;
31199 swig_obj[0] = args;
31200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31201 if (!SWIG_IsOK(res1)) {
31202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31203 }
31204 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31205 {
31206 PyThreadState* __tstate = wxPyBeginAllowThreads();
31207 {
31208 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31209 result = (wxDataFormat *) &_result_ref;
31210 }
31211 wxPyEndAllowThreads(__tstate);
31212 if (PyErr_Occurred()) SWIG_fail;
31213 }
31214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31222 PyObject *resultobj = 0;
31223 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31224 wxDataFormat *arg2 = 0 ;
31225 void *argp1 = 0 ;
31226 int res1 = 0 ;
31227 void *argp2 = 0 ;
31228 int res2 = 0 ;
31229 PyObject * obj0 = 0 ;
31230 PyObject * obj1 = 0 ;
31231 char * kwnames[] = {
31232 (char *) "self",(char *) "format", NULL
31233 };
31234
31235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31237 if (!SWIG_IsOK(res1)) {
31238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31239 }
31240 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31241 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31242 if (!SWIG_IsOK(res2)) {
31243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31244 }
31245 if (!argp2) {
31246 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31247 }
31248 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 resultobj = SWIG_Py_Void();
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31263 PyObject *resultobj = 0;
31264 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31265 size_t result;
31266 void *argp1 = 0 ;
31267 int res1 = 0 ;
31268 PyObject *swig_obj[1] ;
31269
31270 if (!args) SWIG_fail;
31271 swig_obj[0] = args;
31272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31273 if (!SWIG_IsOK(res1)) {
31274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31275 }
31276 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31277 {
31278 PyThreadState* __tstate = wxPyBeginAllowThreads();
31279 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31291 PyObject *resultobj = 0;
31292 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31293 PyObject *result = 0 ;
31294 void *argp1 = 0 ;
31295 int res1 = 0 ;
31296 PyObject *swig_obj[1] ;
31297
31298 if (!args) SWIG_fail;
31299 swig_obj[0] = args;
31300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31301 if (!SWIG_IsOK(res1)) {
31302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31303 }
31304 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31305 {
31306 PyThreadState* __tstate = wxPyBeginAllowThreads();
31307 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31308 wxPyEndAllowThreads(__tstate);
31309 if (PyErr_Occurred()) SWIG_fail;
31310 }
31311 resultobj = result;
31312 return resultobj;
31313 fail:
31314 return NULL;
31315 }
31316
31317
31318 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31319 PyObject *resultobj = 0;
31320 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31321 PyObject *arg2 = (PyObject *) 0 ;
31322 bool result;
31323 void *argp1 = 0 ;
31324 int res1 = 0 ;
31325 PyObject * obj0 = 0 ;
31326 PyObject * obj1 = 0 ;
31327 char * kwnames[] = {
31328 (char *) "self",(char *) "data", NULL
31329 };
31330
31331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31333 if (!SWIG_IsOK(res1)) {
31334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31335 }
31336 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31337 arg2 = obj1;
31338 {
31339 PyThreadState* __tstate = wxPyBeginAllowThreads();
31340 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31341 wxPyEndAllowThreads(__tstate);
31342 if (PyErr_Occurred()) SWIG_fail;
31343 }
31344 {
31345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31346 }
31347 return resultobj;
31348 fail:
31349 return NULL;
31350 }
31351
31352
31353 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31354 PyObject *obj;
31355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31356 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31357 return SWIG_Py_Void();
31358 }
31359
31360 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31361 return SWIG_Python_InitShadowInstance(args);
31362 }
31363
31364 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31365 PyObject *resultobj = 0;
31366 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31367 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31368 wxPyDataObjectSimple *result = 0 ;
31369 void *argp1 = 0 ;
31370 int res1 = 0 ;
31371 PyObject * obj0 = 0 ;
31372 char * kwnames[] = {
31373 (char *) "format", NULL
31374 };
31375
31376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31377 if (obj0) {
31378 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31379 if (!SWIG_IsOK(res1)) {
31380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31381 }
31382 if (!argp1) {
31383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31384 }
31385 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31386 }
31387 {
31388 PyThreadState* __tstate = wxPyBeginAllowThreads();
31389 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31390 wxPyEndAllowThreads(__tstate);
31391 if (PyErr_Occurred()) SWIG_fail;
31392 }
31393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31394 return resultobj;
31395 fail:
31396 return NULL;
31397 }
31398
31399
31400 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31401 PyObject *resultobj = 0;
31402 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31403 PyObject *arg2 = (PyObject *) 0 ;
31404 PyObject *arg3 = (PyObject *) 0 ;
31405 void *argp1 = 0 ;
31406 int res1 = 0 ;
31407 PyObject * obj0 = 0 ;
31408 PyObject * obj1 = 0 ;
31409 PyObject * obj2 = 0 ;
31410 char * kwnames[] = {
31411 (char *) "self",(char *) "self",(char *) "_class", NULL
31412 };
31413
31414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31416 if (!SWIG_IsOK(res1)) {
31417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31418 }
31419 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31420 arg2 = obj1;
31421 arg3 = obj2;
31422 {
31423 PyThreadState* __tstate = wxPyBeginAllowThreads();
31424 (arg1)->_setCallbackInfo(arg2,arg3);
31425 wxPyEndAllowThreads(__tstate);
31426 if (PyErr_Occurred()) SWIG_fail;
31427 }
31428 resultobj = SWIG_Py_Void();
31429 return resultobj;
31430 fail:
31431 return NULL;
31432 }
31433
31434
31435 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31436 PyObject *obj;
31437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31438 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31439 return SWIG_Py_Void();
31440 }
31441
31442 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31443 return SWIG_Python_InitShadowInstance(args);
31444 }
31445
31446 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31447 PyObject *resultobj = 0;
31448 wxDataObjectComposite *result = 0 ;
31449
31450 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31451 {
31452 PyThreadState* __tstate = wxPyBeginAllowThreads();
31453 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31454 wxPyEndAllowThreads(__tstate);
31455 if (PyErr_Occurred()) SWIG_fail;
31456 }
31457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31458 return resultobj;
31459 fail:
31460 return NULL;
31461 }
31462
31463
31464 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31465 PyObject *resultobj = 0;
31466 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31467 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31468 bool arg3 = (bool) false ;
31469 void *argp1 = 0 ;
31470 int res1 = 0 ;
31471 int res2 = 0 ;
31472 bool val3 ;
31473 int ecode3 = 0 ;
31474 PyObject * obj0 = 0 ;
31475 PyObject * obj1 = 0 ;
31476 PyObject * obj2 = 0 ;
31477 char * kwnames[] = {
31478 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31479 };
31480
31481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31483 if (!SWIG_IsOK(res1)) {
31484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31485 }
31486 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31487 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31488 if (!SWIG_IsOK(res2)) {
31489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31490 }
31491 if (obj2) {
31492 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31493 if (!SWIG_IsOK(ecode3)) {
31494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31495 }
31496 arg3 = static_cast< bool >(val3);
31497 }
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 (arg1)->Add(arg2,arg3);
31501 wxPyEndAllowThreads(__tstate);
31502 if (PyErr_Occurred()) SWIG_fail;
31503 }
31504 resultobj = SWIG_Py_Void();
31505 return resultobj;
31506 fail:
31507 return NULL;
31508 }
31509
31510
31511 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31512 PyObject *resultobj = 0;
31513 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31514 SwigValueWrapper<wxDataFormat > result;
31515 void *argp1 = 0 ;
31516 int res1 = 0 ;
31517 PyObject *swig_obj[1] ;
31518
31519 if (!args) SWIG_fail;
31520 swig_obj[0] = args;
31521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31522 if (!SWIG_IsOK(res1)) {
31523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31524 }
31525 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31526 {
31527 PyThreadState* __tstate = wxPyBeginAllowThreads();
31528 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31529 wxPyEndAllowThreads(__tstate);
31530 if (PyErr_Occurred()) SWIG_fail;
31531 }
31532 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31533 return resultobj;
31534 fail:
31535 return NULL;
31536 }
31537
31538
31539 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31540 PyObject *obj;
31541 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31542 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31543 return SWIG_Py_Void();
31544 }
31545
31546 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31547 return SWIG_Python_InitShadowInstance(args);
31548 }
31549
31550 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31551 PyObject *resultobj = 0;
31552 wxString const &arg1_defvalue = wxPyEmptyString ;
31553 wxString *arg1 = (wxString *) &arg1_defvalue ;
31554 wxTextDataObject *result = 0 ;
31555 bool temp1 = false ;
31556 PyObject * obj0 = 0 ;
31557 char * kwnames[] = {
31558 (char *) "text", NULL
31559 };
31560
31561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31562 if (obj0) {
31563 {
31564 arg1 = wxString_in_helper(obj0);
31565 if (arg1 == NULL) SWIG_fail;
31566 temp1 = true;
31567 }
31568 }
31569 {
31570 PyThreadState* __tstate = wxPyBeginAllowThreads();
31571 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31572 wxPyEndAllowThreads(__tstate);
31573 if (PyErr_Occurred()) SWIG_fail;
31574 }
31575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31576 {
31577 if (temp1)
31578 delete arg1;
31579 }
31580 return resultobj;
31581 fail:
31582 {
31583 if (temp1)
31584 delete arg1;
31585 }
31586 return NULL;
31587 }
31588
31589
31590 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31591 PyObject *resultobj = 0;
31592 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31593 size_t result;
31594 void *argp1 = 0 ;
31595 int res1 = 0 ;
31596 PyObject *swig_obj[1] ;
31597
31598 if (!args) SWIG_fail;
31599 swig_obj[0] = args;
31600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31601 if (!SWIG_IsOK(res1)) {
31602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31603 }
31604 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31605 {
31606 PyThreadState* __tstate = wxPyBeginAllowThreads();
31607 result = (size_t)(arg1)->GetTextLength();
31608 wxPyEndAllowThreads(__tstate);
31609 if (PyErr_Occurred()) SWIG_fail;
31610 }
31611 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31612 return resultobj;
31613 fail:
31614 return NULL;
31615 }
31616
31617
31618 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31619 PyObject *resultobj = 0;
31620 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31621 wxString result;
31622 void *argp1 = 0 ;
31623 int res1 = 0 ;
31624 PyObject *swig_obj[1] ;
31625
31626 if (!args) SWIG_fail;
31627 swig_obj[0] = args;
31628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31629 if (!SWIG_IsOK(res1)) {
31630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31631 }
31632 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31633 {
31634 PyThreadState* __tstate = wxPyBeginAllowThreads();
31635 result = (arg1)->GetText();
31636 wxPyEndAllowThreads(__tstate);
31637 if (PyErr_Occurred()) SWIG_fail;
31638 }
31639 {
31640 #if wxUSE_UNICODE
31641 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31642 #else
31643 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31644 #endif
31645 }
31646 return resultobj;
31647 fail:
31648 return NULL;
31649 }
31650
31651
31652 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31653 PyObject *resultobj = 0;
31654 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31655 wxString *arg2 = 0 ;
31656 void *argp1 = 0 ;
31657 int res1 = 0 ;
31658 bool temp2 = false ;
31659 PyObject * obj0 = 0 ;
31660 PyObject * obj1 = 0 ;
31661 char * kwnames[] = {
31662 (char *) "self",(char *) "text", NULL
31663 };
31664
31665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31667 if (!SWIG_IsOK(res1)) {
31668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31669 }
31670 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31671 {
31672 arg2 = wxString_in_helper(obj1);
31673 if (arg2 == NULL) SWIG_fail;
31674 temp2 = true;
31675 }
31676 {
31677 PyThreadState* __tstate = wxPyBeginAllowThreads();
31678 (arg1)->SetText((wxString const &)*arg2);
31679 wxPyEndAllowThreads(__tstate);
31680 if (PyErr_Occurred()) SWIG_fail;
31681 }
31682 resultobj = SWIG_Py_Void();
31683 {
31684 if (temp2)
31685 delete arg2;
31686 }
31687 return resultobj;
31688 fail:
31689 {
31690 if (temp2)
31691 delete arg2;
31692 }
31693 return NULL;
31694 }
31695
31696
31697 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31698 PyObject *obj;
31699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31700 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31701 return SWIG_Py_Void();
31702 }
31703
31704 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31705 return SWIG_Python_InitShadowInstance(args);
31706 }
31707
31708 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31709 PyObject *resultobj = 0;
31710 wxString const &arg1_defvalue = wxPyEmptyString ;
31711 wxString *arg1 = (wxString *) &arg1_defvalue ;
31712 wxPyTextDataObject *result = 0 ;
31713 bool temp1 = false ;
31714 PyObject * obj0 = 0 ;
31715 char * kwnames[] = {
31716 (char *) "text", NULL
31717 };
31718
31719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31720 if (obj0) {
31721 {
31722 arg1 = wxString_in_helper(obj0);
31723 if (arg1 == NULL) SWIG_fail;
31724 temp1 = true;
31725 }
31726 }
31727 {
31728 PyThreadState* __tstate = wxPyBeginAllowThreads();
31729 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31730 wxPyEndAllowThreads(__tstate);
31731 if (PyErr_Occurred()) SWIG_fail;
31732 }
31733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31734 {
31735 if (temp1)
31736 delete arg1;
31737 }
31738 return resultobj;
31739 fail:
31740 {
31741 if (temp1)
31742 delete arg1;
31743 }
31744 return NULL;
31745 }
31746
31747
31748 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31749 PyObject *resultobj = 0;
31750 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31751 PyObject *arg2 = (PyObject *) 0 ;
31752 PyObject *arg3 = (PyObject *) 0 ;
31753 void *argp1 = 0 ;
31754 int res1 = 0 ;
31755 PyObject * obj0 = 0 ;
31756 PyObject * obj1 = 0 ;
31757 PyObject * obj2 = 0 ;
31758 char * kwnames[] = {
31759 (char *) "self",(char *) "self",(char *) "_class", NULL
31760 };
31761
31762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31764 if (!SWIG_IsOK(res1)) {
31765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31766 }
31767 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31768 arg2 = obj1;
31769 arg3 = obj2;
31770 {
31771 PyThreadState* __tstate = wxPyBeginAllowThreads();
31772 (arg1)->_setCallbackInfo(arg2,arg3);
31773 wxPyEndAllowThreads(__tstate);
31774 if (PyErr_Occurred()) SWIG_fail;
31775 }
31776 resultobj = SWIG_Py_Void();
31777 return resultobj;
31778 fail:
31779 return NULL;
31780 }
31781
31782
31783 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31784 PyObject *obj;
31785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31786 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31787 return SWIG_Py_Void();
31788 }
31789
31790 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31791 return SWIG_Python_InitShadowInstance(args);
31792 }
31793
31794 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31795 PyObject *resultobj = 0;
31796 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31797 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31798 wxBitmapDataObject *result = 0 ;
31799 void *argp1 = 0 ;
31800 int res1 = 0 ;
31801 PyObject * obj0 = 0 ;
31802 char * kwnames[] = {
31803 (char *) "bitmap", NULL
31804 };
31805
31806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31807 if (obj0) {
31808 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31809 if (!SWIG_IsOK(res1)) {
31810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31811 }
31812 if (!argp1) {
31813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31814 }
31815 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31816 }
31817 {
31818 PyThreadState* __tstate = wxPyBeginAllowThreads();
31819 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31820 wxPyEndAllowThreads(__tstate);
31821 if (PyErr_Occurred()) SWIG_fail;
31822 }
31823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31824 return resultobj;
31825 fail:
31826 return NULL;
31827 }
31828
31829
31830 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31831 PyObject *resultobj = 0;
31832 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31833 wxBitmap result;
31834 void *argp1 = 0 ;
31835 int res1 = 0 ;
31836 PyObject *swig_obj[1] ;
31837
31838 if (!args) SWIG_fail;
31839 swig_obj[0] = args;
31840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31841 if (!SWIG_IsOK(res1)) {
31842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31843 }
31844 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31845 {
31846 PyThreadState* __tstate = wxPyBeginAllowThreads();
31847 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31848 wxPyEndAllowThreads(__tstate);
31849 if (PyErr_Occurred()) SWIG_fail;
31850 }
31851 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31852 return resultobj;
31853 fail:
31854 return NULL;
31855 }
31856
31857
31858 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31859 PyObject *resultobj = 0;
31860 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31861 wxBitmap *arg2 = 0 ;
31862 void *argp1 = 0 ;
31863 int res1 = 0 ;
31864 void *argp2 = 0 ;
31865 int res2 = 0 ;
31866 PyObject * obj0 = 0 ;
31867 PyObject * obj1 = 0 ;
31868 char * kwnames[] = {
31869 (char *) "self",(char *) "bitmap", NULL
31870 };
31871
31872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31874 if (!SWIG_IsOK(res1)) {
31875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31876 }
31877 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31878 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31879 if (!SWIG_IsOK(res2)) {
31880 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31881 }
31882 if (!argp2) {
31883 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31884 }
31885 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31886 {
31887 PyThreadState* __tstate = wxPyBeginAllowThreads();
31888 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31889 wxPyEndAllowThreads(__tstate);
31890 if (PyErr_Occurred()) SWIG_fail;
31891 }
31892 resultobj = SWIG_Py_Void();
31893 return resultobj;
31894 fail:
31895 return NULL;
31896 }
31897
31898
31899 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31900 PyObject *obj;
31901 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31902 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31903 return SWIG_Py_Void();
31904 }
31905
31906 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31907 return SWIG_Python_InitShadowInstance(args);
31908 }
31909
31910 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31911 PyObject *resultobj = 0;
31912 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31913 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31914 wxPyBitmapDataObject *result = 0 ;
31915 void *argp1 = 0 ;
31916 int res1 = 0 ;
31917 PyObject * obj0 = 0 ;
31918 char * kwnames[] = {
31919 (char *) "bitmap", NULL
31920 };
31921
31922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31923 if (obj0) {
31924 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31925 if (!SWIG_IsOK(res1)) {
31926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31927 }
31928 if (!argp1) {
31929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31930 }
31931 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31932 }
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31940 return resultobj;
31941 fail:
31942 return NULL;
31943 }
31944
31945
31946 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31947 PyObject *resultobj = 0;
31948 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31949 PyObject *arg2 = (PyObject *) 0 ;
31950 PyObject *arg3 = (PyObject *) 0 ;
31951 void *argp1 = 0 ;
31952 int res1 = 0 ;
31953 PyObject * obj0 = 0 ;
31954 PyObject * obj1 = 0 ;
31955 PyObject * obj2 = 0 ;
31956 char * kwnames[] = {
31957 (char *) "self",(char *) "self",(char *) "_class", NULL
31958 };
31959
31960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31962 if (!SWIG_IsOK(res1)) {
31963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31964 }
31965 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31966 arg2 = obj1;
31967 arg3 = obj2;
31968 {
31969 PyThreadState* __tstate = wxPyBeginAllowThreads();
31970 (arg1)->_setCallbackInfo(arg2,arg3);
31971 wxPyEndAllowThreads(__tstate);
31972 if (PyErr_Occurred()) SWIG_fail;
31973 }
31974 resultobj = SWIG_Py_Void();
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31982 PyObject *obj;
31983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31984 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31985 return SWIG_Py_Void();
31986 }
31987
31988 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31989 return SWIG_Python_InitShadowInstance(args);
31990 }
31991
31992 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31993 PyObject *resultobj = 0;
31994 wxFileDataObject *result = 0 ;
31995
31996 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31997 {
31998 PyThreadState* __tstate = wxPyBeginAllowThreads();
31999 result = (wxFileDataObject *)new wxFileDataObject();
32000 wxPyEndAllowThreads(__tstate);
32001 if (PyErr_Occurred()) SWIG_fail;
32002 }
32003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
32004 return resultobj;
32005 fail:
32006 return NULL;
32007 }
32008
32009
32010 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32011 PyObject *resultobj = 0;
32012 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32013 wxArrayString *result = 0 ;
32014 void *argp1 = 0 ;
32015 int res1 = 0 ;
32016 PyObject *swig_obj[1] ;
32017
32018 if (!args) SWIG_fail;
32019 swig_obj[0] = args;
32020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32021 if (!SWIG_IsOK(res1)) {
32022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32023 }
32024 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32025 {
32026 PyThreadState* __tstate = wxPyBeginAllowThreads();
32027 {
32028 wxArrayString const &_result_ref = (arg1)->GetFilenames();
32029 result = (wxArrayString *) &_result_ref;
32030 }
32031 wxPyEndAllowThreads(__tstate);
32032 if (PyErr_Occurred()) SWIG_fail;
32033 }
32034 {
32035 resultobj = wxArrayString2PyList_helper(*result);
32036 }
32037 return resultobj;
32038 fail:
32039 return NULL;
32040 }
32041
32042
32043 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32044 PyObject *resultobj = 0;
32045 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32046 wxString *arg2 = 0 ;
32047 void *argp1 = 0 ;
32048 int res1 = 0 ;
32049 bool temp2 = false ;
32050 PyObject * obj0 = 0 ;
32051 PyObject * obj1 = 0 ;
32052 char * kwnames[] = {
32053 (char *) "self",(char *) "filename", NULL
32054 };
32055
32056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
32057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32058 if (!SWIG_IsOK(res1)) {
32059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32060 }
32061 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32062 {
32063 arg2 = wxString_in_helper(obj1);
32064 if (arg2 == NULL) SWIG_fail;
32065 temp2 = true;
32066 }
32067 {
32068 PyThreadState* __tstate = wxPyBeginAllowThreads();
32069 (arg1)->AddFile((wxString const &)*arg2);
32070 wxPyEndAllowThreads(__tstate);
32071 if (PyErr_Occurred()) SWIG_fail;
32072 }
32073 resultobj = SWIG_Py_Void();
32074 {
32075 if (temp2)
32076 delete arg2;
32077 }
32078 return resultobj;
32079 fail:
32080 {
32081 if (temp2)
32082 delete arg2;
32083 }
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32089 PyObject *obj;
32090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32091 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
32092 return SWIG_Py_Void();
32093 }
32094
32095 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32096 return SWIG_Python_InitShadowInstance(args);
32097 }
32098
32099 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32100 PyObject *resultobj = 0;
32101 wxDataFormat *arg1 = 0 ;
32102 wxCustomDataObject *result = 0 ;
32103 void *argp1 = 0 ;
32104 int res1 = 0 ;
32105
32106 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32108 if (!SWIG_IsOK(res1)) {
32109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32110 }
32111 if (!argp1) {
32112 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32113 }
32114 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32122 return resultobj;
32123 fail:
32124 return NULL;
32125 }
32126
32127
32128 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32129 PyObject *resultobj = 0;
32130 wxString *arg1 = 0 ;
32131 wxCustomDataObject *result = 0 ;
32132 bool temp1 = false ;
32133
32134 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32135 {
32136 arg1 = wxString_in_helper(swig_obj[0]);
32137 if (arg1 == NULL) SWIG_fail;
32138 temp1 = true;
32139 }
32140 {
32141 PyThreadState* __tstate = wxPyBeginAllowThreads();
32142 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32143 wxPyEndAllowThreads(__tstate);
32144 if (PyErr_Occurred()) SWIG_fail;
32145 }
32146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32147 {
32148 if (temp1)
32149 delete arg1;
32150 }
32151 return resultobj;
32152 fail:
32153 {
32154 if (temp1)
32155 delete arg1;
32156 }
32157 return NULL;
32158 }
32159
32160
32161 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32162 PyObject *resultobj = 0;
32163 wxCustomDataObject *result = 0 ;
32164
32165 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 result = (wxCustomDataObject *)new wxCustomDataObject();
32169 wxPyEndAllowThreads(__tstate);
32170 if (PyErr_Occurred()) SWIG_fail;
32171 }
32172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32173 return resultobj;
32174 fail:
32175 return NULL;
32176 }
32177
32178
32179 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32180 int argc;
32181 PyObject *argv[2];
32182
32183 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32184 --argc;
32185 if (argc == 0) {
32186 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32187 }
32188 if (argc == 1) {
32189 int _v = 0;
32190 {
32191 {
32192 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32193 }
32194 }
32195 if (!_v) goto check_2;
32196 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32197 }
32198 check_2:
32199
32200 if (argc == 1) {
32201 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32202 }
32203
32204 fail:
32205 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32206 return NULL;
32207 }
32208
32209
32210 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32211 PyObject *resultobj = 0;
32212 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32213 PyObject *arg2 = (PyObject *) 0 ;
32214 bool result;
32215 void *argp1 = 0 ;
32216 int res1 = 0 ;
32217 PyObject * obj0 = 0 ;
32218 PyObject * obj1 = 0 ;
32219 char * kwnames[] = {
32220 (char *) "self",(char *) "data", NULL
32221 };
32222
32223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32225 if (!SWIG_IsOK(res1)) {
32226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32227 }
32228 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32229 arg2 = obj1;
32230 {
32231 PyThreadState* __tstate = wxPyBeginAllowThreads();
32232 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32233 wxPyEndAllowThreads(__tstate);
32234 if (PyErr_Occurred()) SWIG_fail;
32235 }
32236 {
32237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32238 }
32239 return resultobj;
32240 fail:
32241 return NULL;
32242 }
32243
32244
32245 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32246 PyObject *resultobj = 0;
32247 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32248 size_t result;
32249 void *argp1 = 0 ;
32250 int res1 = 0 ;
32251 PyObject *swig_obj[1] ;
32252
32253 if (!args) SWIG_fail;
32254 swig_obj[0] = args;
32255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32256 if (!SWIG_IsOK(res1)) {
32257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32258 }
32259 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32260 {
32261 PyThreadState* __tstate = wxPyBeginAllowThreads();
32262 result = (size_t)(arg1)->GetSize();
32263 wxPyEndAllowThreads(__tstate);
32264 if (PyErr_Occurred()) SWIG_fail;
32265 }
32266 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32267 return resultobj;
32268 fail:
32269 return NULL;
32270 }
32271
32272
32273 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32274 PyObject *resultobj = 0;
32275 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32276 PyObject *result = 0 ;
32277 void *argp1 = 0 ;
32278 int res1 = 0 ;
32279 PyObject *swig_obj[1] ;
32280
32281 if (!args) SWIG_fail;
32282 swig_obj[0] = args;
32283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32284 if (!SWIG_IsOK(res1)) {
32285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32286 }
32287 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32288 {
32289 PyThreadState* __tstate = wxPyBeginAllowThreads();
32290 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32291 wxPyEndAllowThreads(__tstate);
32292 if (PyErr_Occurred()) SWIG_fail;
32293 }
32294 resultobj = result;
32295 return resultobj;
32296 fail:
32297 return NULL;
32298 }
32299
32300
32301 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32302 PyObject *obj;
32303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32304 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32305 return SWIG_Py_Void();
32306 }
32307
32308 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32309 return SWIG_Python_InitShadowInstance(args);
32310 }
32311
32312 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32313 PyObject *resultobj = 0;
32314 wxURLDataObject *result = 0 ;
32315
32316 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32317 {
32318 PyThreadState* __tstate = wxPyBeginAllowThreads();
32319 result = (wxURLDataObject *)new wxURLDataObject();
32320 wxPyEndAllowThreads(__tstate);
32321 if (PyErr_Occurred()) SWIG_fail;
32322 }
32323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32324 return resultobj;
32325 fail:
32326 return NULL;
32327 }
32328
32329
32330 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32331 PyObject *resultobj = 0;
32332 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32333 wxString result;
32334 void *argp1 = 0 ;
32335 int res1 = 0 ;
32336 PyObject *swig_obj[1] ;
32337
32338 if (!args) SWIG_fail;
32339 swig_obj[0] = args;
32340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32341 if (!SWIG_IsOK(res1)) {
32342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32343 }
32344 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32345 {
32346 PyThreadState* __tstate = wxPyBeginAllowThreads();
32347 result = (arg1)->GetURL();
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 {
32352 #if wxUSE_UNICODE
32353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32354 #else
32355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32356 #endif
32357 }
32358 return resultobj;
32359 fail:
32360 return NULL;
32361 }
32362
32363
32364 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32365 PyObject *resultobj = 0;
32366 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32367 wxString *arg2 = 0 ;
32368 void *argp1 = 0 ;
32369 int res1 = 0 ;
32370 bool temp2 = false ;
32371 PyObject * obj0 = 0 ;
32372 PyObject * obj1 = 0 ;
32373 char * kwnames[] = {
32374 (char *) "self",(char *) "url", NULL
32375 };
32376
32377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32379 if (!SWIG_IsOK(res1)) {
32380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32381 }
32382 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32383 {
32384 arg2 = wxString_in_helper(obj1);
32385 if (arg2 == NULL) SWIG_fail;
32386 temp2 = true;
32387 }
32388 {
32389 PyThreadState* __tstate = wxPyBeginAllowThreads();
32390 (arg1)->SetURL((wxString const &)*arg2);
32391 wxPyEndAllowThreads(__tstate);
32392 if (PyErr_Occurred()) SWIG_fail;
32393 }
32394 resultobj = SWIG_Py_Void();
32395 {
32396 if (temp2)
32397 delete arg2;
32398 }
32399 return resultobj;
32400 fail:
32401 {
32402 if (temp2)
32403 delete arg2;
32404 }
32405 return NULL;
32406 }
32407
32408
32409 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32410 PyObject *obj;
32411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32412 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32413 return SWIG_Py_Void();
32414 }
32415
32416 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32417 return SWIG_Python_InitShadowInstance(args);
32418 }
32419
32420 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32421 PyObject *resultobj = 0;
32422 wxMetafileDataObject *result = 0 ;
32423
32424 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32425 {
32426 PyThreadState* __tstate = wxPyBeginAllowThreads();
32427 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32428 wxPyEndAllowThreads(__tstate);
32429 if (PyErr_Occurred()) SWIG_fail;
32430 }
32431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32432 return resultobj;
32433 fail:
32434 return NULL;
32435 }
32436
32437
32438 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32439 PyObject *obj;
32440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32441 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32442 return SWIG_Py_Void();
32443 }
32444
32445 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32446 return SWIG_Python_InitShadowInstance(args);
32447 }
32448
32449 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32450 PyObject *resultobj = 0;
32451 wxDragResult arg1 ;
32452 bool result;
32453 int val1 ;
32454 int ecode1 = 0 ;
32455 PyObject * obj0 = 0 ;
32456 char * kwnames[] = {
32457 (char *) "res", NULL
32458 };
32459
32460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32461 ecode1 = SWIG_AsVal_int(obj0, &val1);
32462 if (!SWIG_IsOK(ecode1)) {
32463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32464 }
32465 arg1 = static_cast< wxDragResult >(val1);
32466 {
32467 PyThreadState* __tstate = wxPyBeginAllowThreads();
32468 result = (bool)wxIsDragResultOk(arg1);
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 {
32473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32474 }
32475 return resultobj;
32476 fail:
32477 return NULL;
32478 }
32479
32480
32481 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32482 PyObject *resultobj = 0;
32483 wxWindow *arg1 = (wxWindow *) 0 ;
32484 wxIcon const &arg2_defvalue = wxNullIcon ;
32485 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
32486 wxIcon const &arg3_defvalue = wxNullIcon ;
32487 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
32488 wxIcon const &arg4_defvalue = wxNullIcon ;
32489 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
32490 wxPyDropSource *result = 0 ;
32491 void *argp1 = 0 ;
32492 int res1 = 0 ;
32493 void *argp2 = 0 ;
32494 int res2 = 0 ;
32495 void *argp3 = 0 ;
32496 int res3 = 0 ;
32497 void *argp4 = 0 ;
32498 int res4 = 0 ;
32499 PyObject * obj0 = 0 ;
32500 PyObject * obj1 = 0 ;
32501 PyObject * obj2 = 0 ;
32502 PyObject * obj3 = 0 ;
32503 char * kwnames[] = {
32504 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32505 };
32506
32507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32509 if (!SWIG_IsOK(res1)) {
32510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32511 }
32512 arg1 = reinterpret_cast< wxWindow * >(argp1);
32513 if (obj1) {
32514 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
32515 if (!SWIG_IsOK(res2)) {
32516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32517 }
32518 if (!argp2) {
32519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32520 }
32521 arg2 = reinterpret_cast< wxIcon * >(argp2);
32522 }
32523 if (obj2) {
32524 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
32525 if (!SWIG_IsOK(res3)) {
32526 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32527 }
32528 if (!argp3) {
32529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32530 }
32531 arg3 = reinterpret_cast< wxIcon * >(argp3);
32532 }
32533 if (obj3) {
32534 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
32535 if (!SWIG_IsOK(res4)) {
32536 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32537 }
32538 if (!argp4) {
32539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32540 }
32541 arg4 = reinterpret_cast< wxIcon * >(argp4);
32542 }
32543 {
32544 PyThreadState* __tstate = wxPyBeginAllowThreads();
32545 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
32546 wxPyEndAllowThreads(__tstate);
32547 if (PyErr_Occurred()) SWIG_fail;
32548 }
32549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32550 return resultobj;
32551 fail:
32552 return NULL;
32553 }
32554
32555
32556 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32557 PyObject *resultobj = 0;
32558 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32559 PyObject *arg2 = (PyObject *) 0 ;
32560 PyObject *arg3 = (PyObject *) 0 ;
32561 int arg4 ;
32562 void *argp1 = 0 ;
32563 int res1 = 0 ;
32564 int val4 ;
32565 int ecode4 = 0 ;
32566 PyObject * obj0 = 0 ;
32567 PyObject * obj1 = 0 ;
32568 PyObject * obj2 = 0 ;
32569 PyObject * obj3 = 0 ;
32570 char * kwnames[] = {
32571 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32572 };
32573
32574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32576 if (!SWIG_IsOK(res1)) {
32577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32578 }
32579 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32580 arg2 = obj1;
32581 arg3 = obj2;
32582 ecode4 = SWIG_AsVal_int(obj3, &val4);
32583 if (!SWIG_IsOK(ecode4)) {
32584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32585 }
32586 arg4 = static_cast< int >(val4);
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32590 wxPyEndAllowThreads(__tstate);
32591 if (PyErr_Occurred()) SWIG_fail;
32592 }
32593 resultobj = SWIG_Py_Void();
32594 return resultobj;
32595 fail:
32596 return NULL;
32597 }
32598
32599
32600 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32601 PyObject *resultobj = 0;
32602 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32603 void *argp1 = 0 ;
32604 int res1 = 0 ;
32605 PyObject *swig_obj[1] ;
32606
32607 if (!args) SWIG_fail;
32608 swig_obj[0] = args;
32609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32610 if (!SWIG_IsOK(res1)) {
32611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32612 }
32613 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32614 {
32615 PyThreadState* __tstate = wxPyBeginAllowThreads();
32616 delete arg1;
32617
32618 wxPyEndAllowThreads(__tstate);
32619 if (PyErr_Occurred()) SWIG_fail;
32620 }
32621 resultobj = SWIG_Py_Void();
32622 return resultobj;
32623 fail:
32624 return NULL;
32625 }
32626
32627
32628 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32629 PyObject *resultobj = 0;
32630 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32631 wxDataObject *arg2 = 0 ;
32632 void *argp1 = 0 ;
32633 int res1 = 0 ;
32634 void *argp2 = 0 ;
32635 int res2 = 0 ;
32636 PyObject * obj0 = 0 ;
32637 PyObject * obj1 = 0 ;
32638 char * kwnames[] = {
32639 (char *) "self",(char *) "data", NULL
32640 };
32641
32642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32644 if (!SWIG_IsOK(res1)) {
32645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32646 }
32647 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32648 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32649 if (!SWIG_IsOK(res2)) {
32650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32651 }
32652 if (!argp2) {
32653 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32654 }
32655 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32656 {
32657 PyThreadState* __tstate = wxPyBeginAllowThreads();
32658 (arg1)->SetData(*arg2);
32659 wxPyEndAllowThreads(__tstate);
32660 if (PyErr_Occurred()) SWIG_fail;
32661 }
32662 resultobj = SWIG_Py_Void();
32663 return resultobj;
32664 fail:
32665 return NULL;
32666 }
32667
32668
32669 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32670 PyObject *resultobj = 0;
32671 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32672 wxDataObject *result = 0 ;
32673 void *argp1 = 0 ;
32674 int res1 = 0 ;
32675 PyObject *swig_obj[1] ;
32676
32677 if (!args) SWIG_fail;
32678 swig_obj[0] = args;
32679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32680 if (!SWIG_IsOK(res1)) {
32681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32682 }
32683 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32684 {
32685 PyThreadState* __tstate = wxPyBeginAllowThreads();
32686 result = (wxDataObject *)(arg1)->GetDataObject();
32687 wxPyEndAllowThreads(__tstate);
32688 if (PyErr_Occurred()) SWIG_fail;
32689 }
32690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32691 return resultobj;
32692 fail:
32693 return NULL;
32694 }
32695
32696
32697 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32698 PyObject *resultobj = 0;
32699 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32700 wxDragResult arg2 ;
32701 wxCursor *arg3 = 0 ;
32702 void *argp1 = 0 ;
32703 int res1 = 0 ;
32704 int val2 ;
32705 int ecode2 = 0 ;
32706 void *argp3 = 0 ;
32707 int res3 = 0 ;
32708 PyObject * obj0 = 0 ;
32709 PyObject * obj1 = 0 ;
32710 PyObject * obj2 = 0 ;
32711 char * kwnames[] = {
32712 (char *) "self",(char *) "res",(char *) "cursor", NULL
32713 };
32714
32715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32717 if (!SWIG_IsOK(res1)) {
32718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32719 }
32720 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32721 ecode2 = SWIG_AsVal_int(obj1, &val2);
32722 if (!SWIG_IsOK(ecode2)) {
32723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32724 }
32725 arg2 = static_cast< wxDragResult >(val2);
32726 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32727 if (!SWIG_IsOK(res3)) {
32728 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32729 }
32730 if (!argp3) {
32731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32732 }
32733 arg3 = reinterpret_cast< wxCursor * >(argp3);
32734 {
32735 PyThreadState* __tstate = wxPyBeginAllowThreads();
32736 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32737 wxPyEndAllowThreads(__tstate);
32738 if (PyErr_Occurred()) SWIG_fail;
32739 }
32740 resultobj = SWIG_Py_Void();
32741 return resultobj;
32742 fail:
32743 return NULL;
32744 }
32745
32746
32747 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32748 PyObject *resultobj = 0;
32749 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32750 int arg2 = (int) wxDrag_CopyOnly ;
32751 wxDragResult result;
32752 void *argp1 = 0 ;
32753 int res1 = 0 ;
32754 int val2 ;
32755 int ecode2 = 0 ;
32756 PyObject * obj0 = 0 ;
32757 PyObject * obj1 = 0 ;
32758 char * kwnames[] = {
32759 (char *) "self",(char *) "flags", NULL
32760 };
32761
32762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32764 if (!SWIG_IsOK(res1)) {
32765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32766 }
32767 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32768 if (obj1) {
32769 ecode2 = SWIG_AsVal_int(obj1, &val2);
32770 if (!SWIG_IsOK(ecode2)) {
32771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32772 }
32773 arg2 = static_cast< int >(val2);
32774 }
32775 {
32776 PyThreadState* __tstate = wxPyBeginAllowThreads();
32777 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32778 wxPyEndAllowThreads(__tstate);
32779 if (PyErr_Occurred()) SWIG_fail;
32780 }
32781 resultobj = SWIG_From_int(static_cast< int >(result));
32782 return resultobj;
32783 fail:
32784 return NULL;
32785 }
32786
32787
32788 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32789 PyObject *resultobj = 0;
32790 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32791 wxDragResult arg2 ;
32792 bool result;
32793 void *argp1 = 0 ;
32794 int res1 = 0 ;
32795 int val2 ;
32796 int ecode2 = 0 ;
32797 PyObject * obj0 = 0 ;
32798 PyObject * obj1 = 0 ;
32799 char * kwnames[] = {
32800 (char *) "self",(char *) "effect", NULL
32801 };
32802
32803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32805 if (!SWIG_IsOK(res1)) {
32806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32807 }
32808 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32809 ecode2 = SWIG_AsVal_int(obj1, &val2);
32810 if (!SWIG_IsOK(ecode2)) {
32811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32812 }
32813 arg2 = static_cast< wxDragResult >(val2);
32814 {
32815 PyThreadState* __tstate = wxPyBeginAllowThreads();
32816 result = (bool)(arg1)->GiveFeedback(arg2);
32817 wxPyEndAllowThreads(__tstate);
32818 if (PyErr_Occurred()) SWIG_fail;
32819 }
32820 {
32821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32822 }
32823 return resultobj;
32824 fail:
32825 return NULL;
32826 }
32827
32828
32829 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32830 PyObject *obj;
32831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32832 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32833 return SWIG_Py_Void();
32834 }
32835
32836 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32837 return SWIG_Python_InitShadowInstance(args);
32838 }
32839
32840 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32841 PyObject *resultobj = 0;
32842 wxDataObject *arg1 = (wxDataObject *) NULL ;
32843 wxPyDropTarget *result = 0 ;
32844 int res1 = 0 ;
32845 PyObject * obj0 = 0 ;
32846 char * kwnames[] = {
32847 (char *) "dataObject", NULL
32848 };
32849
32850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32851 if (obj0) {
32852 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32853 if (!SWIG_IsOK(res1)) {
32854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32855 }
32856 }
32857 {
32858 PyThreadState* __tstate = wxPyBeginAllowThreads();
32859 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32860 wxPyEndAllowThreads(__tstate);
32861 if (PyErr_Occurred()) SWIG_fail;
32862 }
32863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32864 return resultobj;
32865 fail:
32866 return NULL;
32867 }
32868
32869
32870 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32871 PyObject *resultobj = 0;
32872 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32873 PyObject *arg2 = (PyObject *) 0 ;
32874 PyObject *arg3 = (PyObject *) 0 ;
32875 void *argp1 = 0 ;
32876 int res1 = 0 ;
32877 PyObject * obj0 = 0 ;
32878 PyObject * obj1 = 0 ;
32879 PyObject * obj2 = 0 ;
32880 char * kwnames[] = {
32881 (char *) "self",(char *) "self",(char *) "_class", NULL
32882 };
32883
32884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32886 if (!SWIG_IsOK(res1)) {
32887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32888 }
32889 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32890 arg2 = obj1;
32891 arg3 = obj2;
32892 {
32893 PyThreadState* __tstate = wxPyBeginAllowThreads();
32894 (arg1)->_setCallbackInfo(arg2,arg3);
32895 wxPyEndAllowThreads(__tstate);
32896 if (PyErr_Occurred()) SWIG_fail;
32897 }
32898 resultobj = SWIG_Py_Void();
32899 return resultobj;
32900 fail:
32901 return NULL;
32902 }
32903
32904
32905 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32906 PyObject *resultobj = 0;
32907 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32908 void *argp1 = 0 ;
32909 int res1 = 0 ;
32910 PyObject *swig_obj[1] ;
32911
32912 if (!args) SWIG_fail;
32913 swig_obj[0] = args;
32914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32915 if (!SWIG_IsOK(res1)) {
32916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32917 }
32918 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32919 {
32920 PyThreadState* __tstate = wxPyBeginAllowThreads();
32921 delete arg1;
32922
32923 wxPyEndAllowThreads(__tstate);
32924 if (PyErr_Occurred()) SWIG_fail;
32925 }
32926 resultobj = SWIG_Py_Void();
32927 return resultobj;
32928 fail:
32929 return NULL;
32930 }
32931
32932
32933 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32934 PyObject *resultobj = 0;
32935 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32936 wxDataObject *result = 0 ;
32937 void *argp1 = 0 ;
32938 int res1 = 0 ;
32939 PyObject *swig_obj[1] ;
32940
32941 if (!args) SWIG_fail;
32942 swig_obj[0] = args;
32943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32944 if (!SWIG_IsOK(res1)) {
32945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32946 }
32947 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32948 {
32949 PyThreadState* __tstate = wxPyBeginAllowThreads();
32950 result = (wxDataObject *)(arg1)->GetDataObject();
32951 wxPyEndAllowThreads(__tstate);
32952 if (PyErr_Occurred()) SWIG_fail;
32953 }
32954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32955 return resultobj;
32956 fail:
32957 return NULL;
32958 }
32959
32960
32961 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32962 PyObject *resultobj = 0;
32963 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32964 wxDataObject *arg2 = (wxDataObject *) 0 ;
32965 void *argp1 = 0 ;
32966 int res1 = 0 ;
32967 int res2 = 0 ;
32968 PyObject * obj0 = 0 ;
32969 PyObject * obj1 = 0 ;
32970 char * kwnames[] = {
32971 (char *) "self",(char *) "dataObject", NULL
32972 };
32973
32974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32976 if (!SWIG_IsOK(res1)) {
32977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32978 }
32979 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32980 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32981 if (!SWIG_IsOK(res2)) {
32982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32983 }
32984 {
32985 PyThreadState* __tstate = wxPyBeginAllowThreads();
32986 (arg1)->SetDataObject(arg2);
32987 wxPyEndAllowThreads(__tstate);
32988 if (PyErr_Occurred()) SWIG_fail;
32989 }
32990 resultobj = SWIG_Py_Void();
32991 return resultobj;
32992 fail:
32993 return NULL;
32994 }
32995
32996
32997 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32998 PyObject *resultobj = 0;
32999 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33000 int arg2 ;
33001 int arg3 ;
33002 wxDragResult arg4 ;
33003 wxDragResult result;
33004 void *argp1 = 0 ;
33005 int res1 = 0 ;
33006 int val2 ;
33007 int ecode2 = 0 ;
33008 int val3 ;
33009 int ecode3 = 0 ;
33010 int val4 ;
33011 int ecode4 = 0 ;
33012 PyObject * obj0 = 0 ;
33013 PyObject * obj1 = 0 ;
33014 PyObject * obj2 = 0 ;
33015 PyObject * obj3 = 0 ;
33016 char * kwnames[] = {
33017 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33018 };
33019
33020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33022 if (!SWIG_IsOK(res1)) {
33023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33024 }
33025 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33026 ecode2 = SWIG_AsVal_int(obj1, &val2);
33027 if (!SWIG_IsOK(ecode2)) {
33028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33029 }
33030 arg2 = static_cast< int >(val2);
33031 ecode3 = SWIG_AsVal_int(obj2, &val3);
33032 if (!SWIG_IsOK(ecode3)) {
33033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33034 }
33035 arg3 = static_cast< int >(val3);
33036 ecode4 = SWIG_AsVal_int(obj3, &val4);
33037 if (!SWIG_IsOK(ecode4)) {
33038 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33039 }
33040 arg4 = static_cast< wxDragResult >(val4);
33041 {
33042 PyThreadState* __tstate = wxPyBeginAllowThreads();
33043 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33044 wxPyEndAllowThreads(__tstate);
33045 if (PyErr_Occurred()) SWIG_fail;
33046 }
33047 resultobj = SWIG_From_int(static_cast< int >(result));
33048 return resultobj;
33049 fail:
33050 return NULL;
33051 }
33052
33053
33054 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33055 PyObject *resultobj = 0;
33056 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33057 int arg2 ;
33058 int arg3 ;
33059 wxDragResult arg4 ;
33060 wxDragResult result;
33061 void *argp1 = 0 ;
33062 int res1 = 0 ;
33063 int val2 ;
33064 int ecode2 = 0 ;
33065 int val3 ;
33066 int ecode3 = 0 ;
33067 int val4 ;
33068 int ecode4 = 0 ;
33069 PyObject * obj0 = 0 ;
33070 PyObject * obj1 = 0 ;
33071 PyObject * obj2 = 0 ;
33072 PyObject * obj3 = 0 ;
33073 char * kwnames[] = {
33074 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33075 };
33076
33077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33079 if (!SWIG_IsOK(res1)) {
33080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33081 }
33082 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33083 ecode2 = SWIG_AsVal_int(obj1, &val2);
33084 if (!SWIG_IsOK(ecode2)) {
33085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33086 }
33087 arg2 = static_cast< int >(val2);
33088 ecode3 = SWIG_AsVal_int(obj2, &val3);
33089 if (!SWIG_IsOK(ecode3)) {
33090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33091 }
33092 arg3 = static_cast< int >(val3);
33093 ecode4 = SWIG_AsVal_int(obj3, &val4);
33094 if (!SWIG_IsOK(ecode4)) {
33095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33096 }
33097 arg4 = static_cast< wxDragResult >(val4);
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 resultobj = SWIG_From_int(static_cast< int >(result));
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33112 PyObject *resultobj = 0;
33113 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33114 void *argp1 = 0 ;
33115 int res1 = 0 ;
33116 PyObject *swig_obj[1] ;
33117
33118 if (!args) SWIG_fail;
33119 swig_obj[0] = args;
33120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33121 if (!SWIG_IsOK(res1)) {
33122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33123 }
33124 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33125 {
33126 PyThreadState* __tstate = wxPyBeginAllowThreads();
33127 (arg1)->OnLeave();
33128 wxPyEndAllowThreads(__tstate);
33129 if (PyErr_Occurred()) SWIG_fail;
33130 }
33131 resultobj = SWIG_Py_Void();
33132 return resultobj;
33133 fail:
33134 return NULL;
33135 }
33136
33137
33138 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33139 PyObject *resultobj = 0;
33140 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33141 int arg2 ;
33142 int arg3 ;
33143 bool result;
33144 void *argp1 = 0 ;
33145 int res1 = 0 ;
33146 int val2 ;
33147 int ecode2 = 0 ;
33148 int val3 ;
33149 int ecode3 = 0 ;
33150 PyObject * obj0 = 0 ;
33151 PyObject * obj1 = 0 ;
33152 PyObject * obj2 = 0 ;
33153 char * kwnames[] = {
33154 (char *) "self",(char *) "x",(char *) "y", NULL
33155 };
33156
33157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33159 if (!SWIG_IsOK(res1)) {
33160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33161 }
33162 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33163 ecode2 = SWIG_AsVal_int(obj1, &val2);
33164 if (!SWIG_IsOK(ecode2)) {
33165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33166 }
33167 arg2 = static_cast< int >(val2);
33168 ecode3 = SWIG_AsVal_int(obj2, &val3);
33169 if (!SWIG_IsOK(ecode3)) {
33170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33171 }
33172 arg3 = static_cast< int >(val3);
33173 {
33174 PyThreadState* __tstate = wxPyBeginAllowThreads();
33175 result = (bool)(arg1)->OnDrop(arg2,arg3);
33176 wxPyEndAllowThreads(__tstate);
33177 if (PyErr_Occurred()) SWIG_fail;
33178 }
33179 {
33180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33181 }
33182 return resultobj;
33183 fail:
33184 return NULL;
33185 }
33186
33187
33188 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33189 PyObject *resultobj = 0;
33190 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33191 bool result;
33192 void *argp1 = 0 ;
33193 int res1 = 0 ;
33194 PyObject *swig_obj[1] ;
33195
33196 if (!args) SWIG_fail;
33197 swig_obj[0] = args;
33198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33199 if (!SWIG_IsOK(res1)) {
33200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33201 }
33202 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33203 {
33204 PyThreadState* __tstate = wxPyBeginAllowThreads();
33205 result = (bool)(arg1)->GetData();
33206 wxPyEndAllowThreads(__tstate);
33207 if (PyErr_Occurred()) SWIG_fail;
33208 }
33209 {
33210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33211 }
33212 return resultobj;
33213 fail:
33214 return NULL;
33215 }
33216
33217
33218 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33219 PyObject *resultobj = 0;
33220 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33221 wxDragResult arg2 ;
33222 void *argp1 = 0 ;
33223 int res1 = 0 ;
33224 int val2 ;
33225 int ecode2 = 0 ;
33226 PyObject * obj0 = 0 ;
33227 PyObject * obj1 = 0 ;
33228 char * kwnames[] = {
33229 (char *) "self",(char *) "action", NULL
33230 };
33231
33232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33234 if (!SWIG_IsOK(res1)) {
33235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33236 }
33237 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33238 ecode2 = SWIG_AsVal_int(obj1, &val2);
33239 if (!SWIG_IsOK(ecode2)) {
33240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33241 }
33242 arg2 = static_cast< wxDragResult >(val2);
33243 {
33244 PyThreadState* __tstate = wxPyBeginAllowThreads();
33245 (arg1)->SetDefaultAction(arg2);
33246 wxPyEndAllowThreads(__tstate);
33247 if (PyErr_Occurred()) SWIG_fail;
33248 }
33249 resultobj = SWIG_Py_Void();
33250 return resultobj;
33251 fail:
33252 return NULL;
33253 }
33254
33255
33256 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33257 PyObject *resultobj = 0;
33258 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33259 wxDragResult result;
33260 void *argp1 = 0 ;
33261 int res1 = 0 ;
33262 PyObject *swig_obj[1] ;
33263
33264 if (!args) SWIG_fail;
33265 swig_obj[0] = args;
33266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33267 if (!SWIG_IsOK(res1)) {
33268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33269 }
33270 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33271 {
33272 PyThreadState* __tstate = wxPyBeginAllowThreads();
33273 result = (wxDragResult)(arg1)->GetDefaultAction();
33274 wxPyEndAllowThreads(__tstate);
33275 if (PyErr_Occurred()) SWIG_fail;
33276 }
33277 resultobj = SWIG_From_int(static_cast< int >(result));
33278 return resultobj;
33279 fail:
33280 return NULL;
33281 }
33282
33283
33284 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33285 PyObject *obj;
33286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33287 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33288 return SWIG_Py_Void();
33289 }
33290
33291 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33292 return SWIG_Python_InitShadowInstance(args);
33293 }
33294
33295 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33296 PyObject *resultobj = 0;
33297 wxPyTextDropTarget *result = 0 ;
33298
33299 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33300 {
33301 PyThreadState* __tstate = wxPyBeginAllowThreads();
33302 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33303 wxPyEndAllowThreads(__tstate);
33304 if (PyErr_Occurred()) SWIG_fail;
33305 }
33306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33307 return resultobj;
33308 fail:
33309 return NULL;
33310 }
33311
33312
33313 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33314 PyObject *resultobj = 0;
33315 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33316 PyObject *arg2 = (PyObject *) 0 ;
33317 PyObject *arg3 = (PyObject *) 0 ;
33318 void *argp1 = 0 ;
33319 int res1 = 0 ;
33320 PyObject * obj0 = 0 ;
33321 PyObject * obj1 = 0 ;
33322 PyObject * obj2 = 0 ;
33323 char * kwnames[] = {
33324 (char *) "self",(char *) "self",(char *) "_class", NULL
33325 };
33326
33327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33329 if (!SWIG_IsOK(res1)) {
33330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33331 }
33332 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33333 arg2 = obj1;
33334 arg3 = obj2;
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 (arg1)->_setCallbackInfo(arg2,arg3);
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 resultobj = SWIG_Py_Void();
33342 return resultobj;
33343 fail:
33344 return NULL;
33345 }
33346
33347
33348 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33349 PyObject *resultobj = 0;
33350 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33351 int arg2 ;
33352 int arg3 ;
33353 wxString *arg4 = 0 ;
33354 bool result;
33355 void *argp1 = 0 ;
33356 int res1 = 0 ;
33357 int val2 ;
33358 int ecode2 = 0 ;
33359 int val3 ;
33360 int ecode3 = 0 ;
33361 bool temp4 = false ;
33362 PyObject * obj0 = 0 ;
33363 PyObject * obj1 = 0 ;
33364 PyObject * obj2 = 0 ;
33365 PyObject * obj3 = 0 ;
33366 char * kwnames[] = {
33367 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33368 };
33369
33370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33372 if (!SWIG_IsOK(res1)) {
33373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33374 }
33375 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33376 ecode2 = SWIG_AsVal_int(obj1, &val2);
33377 if (!SWIG_IsOK(ecode2)) {
33378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33379 }
33380 arg2 = static_cast< int >(val2);
33381 ecode3 = SWIG_AsVal_int(obj2, &val3);
33382 if (!SWIG_IsOK(ecode3)) {
33383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33384 }
33385 arg3 = static_cast< int >(val3);
33386 {
33387 arg4 = wxString_in_helper(obj3);
33388 if (arg4 == NULL) SWIG_fail;
33389 temp4 = true;
33390 }
33391 {
33392 PyThreadState* __tstate = wxPyBeginAllowThreads();
33393 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33394 wxPyEndAllowThreads(__tstate);
33395 if (PyErr_Occurred()) SWIG_fail;
33396 }
33397 {
33398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33399 }
33400 {
33401 if (temp4)
33402 delete arg4;
33403 }
33404 return resultobj;
33405 fail:
33406 {
33407 if (temp4)
33408 delete arg4;
33409 }
33410 return NULL;
33411 }
33412
33413
33414 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33415 PyObject *resultobj = 0;
33416 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33417 int arg2 ;
33418 int arg3 ;
33419 wxDragResult arg4 ;
33420 wxDragResult result;
33421 void *argp1 = 0 ;
33422 int res1 = 0 ;
33423 int val2 ;
33424 int ecode2 = 0 ;
33425 int val3 ;
33426 int ecode3 = 0 ;
33427 int val4 ;
33428 int ecode4 = 0 ;
33429 PyObject * obj0 = 0 ;
33430 PyObject * obj1 = 0 ;
33431 PyObject * obj2 = 0 ;
33432 PyObject * obj3 = 0 ;
33433 char * kwnames[] = {
33434 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33435 };
33436
33437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33439 if (!SWIG_IsOK(res1)) {
33440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33441 }
33442 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33443 ecode2 = SWIG_AsVal_int(obj1, &val2);
33444 if (!SWIG_IsOK(ecode2)) {
33445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33446 }
33447 arg2 = static_cast< int >(val2);
33448 ecode3 = SWIG_AsVal_int(obj2, &val3);
33449 if (!SWIG_IsOK(ecode3)) {
33450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33451 }
33452 arg3 = static_cast< int >(val3);
33453 ecode4 = SWIG_AsVal_int(obj3, &val4);
33454 if (!SWIG_IsOK(ecode4)) {
33455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33456 }
33457 arg4 = static_cast< wxDragResult >(val4);
33458 {
33459 PyThreadState* __tstate = wxPyBeginAllowThreads();
33460 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33461 wxPyEndAllowThreads(__tstate);
33462 if (PyErr_Occurred()) SWIG_fail;
33463 }
33464 resultobj = SWIG_From_int(static_cast< int >(result));
33465 return resultobj;
33466 fail:
33467 return NULL;
33468 }
33469
33470
33471 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33472 PyObject *resultobj = 0;
33473 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33474 int arg2 ;
33475 int arg3 ;
33476 wxDragResult arg4 ;
33477 wxDragResult result;
33478 void *argp1 = 0 ;
33479 int res1 = 0 ;
33480 int val2 ;
33481 int ecode2 = 0 ;
33482 int val3 ;
33483 int ecode3 = 0 ;
33484 int val4 ;
33485 int ecode4 = 0 ;
33486 PyObject * obj0 = 0 ;
33487 PyObject * obj1 = 0 ;
33488 PyObject * obj2 = 0 ;
33489 PyObject * obj3 = 0 ;
33490 char * kwnames[] = {
33491 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33492 };
33493
33494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33496 if (!SWIG_IsOK(res1)) {
33497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33498 }
33499 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33500 ecode2 = SWIG_AsVal_int(obj1, &val2);
33501 if (!SWIG_IsOK(ecode2)) {
33502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33503 }
33504 arg2 = static_cast< int >(val2);
33505 ecode3 = SWIG_AsVal_int(obj2, &val3);
33506 if (!SWIG_IsOK(ecode3)) {
33507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33508 }
33509 arg3 = static_cast< int >(val3);
33510 ecode4 = SWIG_AsVal_int(obj3, &val4);
33511 if (!SWIG_IsOK(ecode4)) {
33512 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33513 }
33514 arg4 = static_cast< wxDragResult >(val4);
33515 {
33516 PyThreadState* __tstate = wxPyBeginAllowThreads();
33517 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33518 wxPyEndAllowThreads(__tstate);
33519 if (PyErr_Occurred()) SWIG_fail;
33520 }
33521 resultobj = SWIG_From_int(static_cast< int >(result));
33522 return resultobj;
33523 fail:
33524 return NULL;
33525 }
33526
33527
33528 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33529 PyObject *resultobj = 0;
33530 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33531 void *argp1 = 0 ;
33532 int res1 = 0 ;
33533 PyObject *swig_obj[1] ;
33534
33535 if (!args) SWIG_fail;
33536 swig_obj[0] = args;
33537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33538 if (!SWIG_IsOK(res1)) {
33539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33540 }
33541 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33542 {
33543 PyThreadState* __tstate = wxPyBeginAllowThreads();
33544 (arg1)->OnLeave();
33545 wxPyEndAllowThreads(__tstate);
33546 if (PyErr_Occurred()) SWIG_fail;
33547 }
33548 resultobj = SWIG_Py_Void();
33549 return resultobj;
33550 fail:
33551 return NULL;
33552 }
33553
33554
33555 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33556 PyObject *resultobj = 0;
33557 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33558 int arg2 ;
33559 int arg3 ;
33560 bool result;
33561 void *argp1 = 0 ;
33562 int res1 = 0 ;
33563 int val2 ;
33564 int ecode2 = 0 ;
33565 int val3 ;
33566 int ecode3 = 0 ;
33567 PyObject * obj0 = 0 ;
33568 PyObject * obj1 = 0 ;
33569 PyObject * obj2 = 0 ;
33570 char * kwnames[] = {
33571 (char *) "self",(char *) "x",(char *) "y", NULL
33572 };
33573
33574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33576 if (!SWIG_IsOK(res1)) {
33577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33578 }
33579 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33580 ecode2 = SWIG_AsVal_int(obj1, &val2);
33581 if (!SWIG_IsOK(ecode2)) {
33582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33583 }
33584 arg2 = static_cast< int >(val2);
33585 ecode3 = SWIG_AsVal_int(obj2, &val3);
33586 if (!SWIG_IsOK(ecode3)) {
33587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33588 }
33589 arg3 = static_cast< int >(val3);
33590 {
33591 PyThreadState* __tstate = wxPyBeginAllowThreads();
33592 result = (bool)(arg1)->OnDrop(arg2,arg3);
33593 wxPyEndAllowThreads(__tstate);
33594 if (PyErr_Occurred()) SWIG_fail;
33595 }
33596 {
33597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33598 }
33599 return resultobj;
33600 fail:
33601 return NULL;
33602 }
33603
33604
33605 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33606 PyObject *resultobj = 0;
33607 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33608 int arg2 ;
33609 int arg3 ;
33610 wxDragResult arg4 ;
33611 wxDragResult result;
33612 void *argp1 = 0 ;
33613 int res1 = 0 ;
33614 int val2 ;
33615 int ecode2 = 0 ;
33616 int val3 ;
33617 int ecode3 = 0 ;
33618 int val4 ;
33619 int ecode4 = 0 ;
33620 PyObject * obj0 = 0 ;
33621 PyObject * obj1 = 0 ;
33622 PyObject * obj2 = 0 ;
33623 PyObject * obj3 = 0 ;
33624 char * kwnames[] = {
33625 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33626 };
33627
33628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33630 if (!SWIG_IsOK(res1)) {
33631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33632 }
33633 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33634 ecode2 = SWIG_AsVal_int(obj1, &val2);
33635 if (!SWIG_IsOK(ecode2)) {
33636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33637 }
33638 arg2 = static_cast< int >(val2);
33639 ecode3 = SWIG_AsVal_int(obj2, &val3);
33640 if (!SWIG_IsOK(ecode3)) {
33641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33642 }
33643 arg3 = static_cast< int >(val3);
33644 ecode4 = SWIG_AsVal_int(obj3, &val4);
33645 if (!SWIG_IsOK(ecode4)) {
33646 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33647 }
33648 arg4 = static_cast< wxDragResult >(val4);
33649 {
33650 PyThreadState* __tstate = wxPyBeginAllowThreads();
33651 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33652 wxPyEndAllowThreads(__tstate);
33653 if (PyErr_Occurred()) SWIG_fail;
33654 }
33655 resultobj = SWIG_From_int(static_cast< int >(result));
33656 return resultobj;
33657 fail:
33658 return NULL;
33659 }
33660
33661
33662 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33663 PyObject *obj;
33664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33665 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33666 return SWIG_Py_Void();
33667 }
33668
33669 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33670 return SWIG_Python_InitShadowInstance(args);
33671 }
33672
33673 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33674 PyObject *resultobj = 0;
33675 wxPyFileDropTarget *result = 0 ;
33676
33677 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33678 {
33679 PyThreadState* __tstate = wxPyBeginAllowThreads();
33680 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33681 wxPyEndAllowThreads(__tstate);
33682 if (PyErr_Occurred()) SWIG_fail;
33683 }
33684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33685 return resultobj;
33686 fail:
33687 return NULL;
33688 }
33689
33690
33691 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33692 PyObject *resultobj = 0;
33693 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33694 PyObject *arg2 = (PyObject *) 0 ;
33695 PyObject *arg3 = (PyObject *) 0 ;
33696 void *argp1 = 0 ;
33697 int res1 = 0 ;
33698 PyObject * obj0 = 0 ;
33699 PyObject * obj1 = 0 ;
33700 PyObject * obj2 = 0 ;
33701 char * kwnames[] = {
33702 (char *) "self",(char *) "self",(char *) "_class", NULL
33703 };
33704
33705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33707 if (!SWIG_IsOK(res1)) {
33708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33709 }
33710 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33711 arg2 = obj1;
33712 arg3 = obj2;
33713 {
33714 PyThreadState* __tstate = wxPyBeginAllowThreads();
33715 (arg1)->_setCallbackInfo(arg2,arg3);
33716 wxPyEndAllowThreads(__tstate);
33717 if (PyErr_Occurred()) SWIG_fail;
33718 }
33719 resultobj = SWIG_Py_Void();
33720 return resultobj;
33721 fail:
33722 return NULL;
33723 }
33724
33725
33726 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33727 PyObject *resultobj = 0;
33728 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33729 int arg2 ;
33730 int arg3 ;
33731 wxArrayString *arg4 = 0 ;
33732 bool result;
33733 void *argp1 = 0 ;
33734 int res1 = 0 ;
33735 int val2 ;
33736 int ecode2 = 0 ;
33737 int val3 ;
33738 int ecode3 = 0 ;
33739 bool temp4 = false ;
33740 PyObject * obj0 = 0 ;
33741 PyObject * obj1 = 0 ;
33742 PyObject * obj2 = 0 ;
33743 PyObject * obj3 = 0 ;
33744 char * kwnames[] = {
33745 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33746 };
33747
33748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33750 if (!SWIG_IsOK(res1)) {
33751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33752 }
33753 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33754 ecode2 = SWIG_AsVal_int(obj1, &val2);
33755 if (!SWIG_IsOK(ecode2)) {
33756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33757 }
33758 arg2 = static_cast< int >(val2);
33759 ecode3 = SWIG_AsVal_int(obj2, &val3);
33760 if (!SWIG_IsOK(ecode3)) {
33761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33762 }
33763 arg3 = static_cast< int >(val3);
33764 {
33765 if (! PySequence_Check(obj3)) {
33766 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33767 SWIG_fail;
33768 }
33769 arg4 = new wxArrayString;
33770 temp4 = true;
33771 int i, len=PySequence_Length(obj3);
33772 for (i=0; i<len; i++) {
33773 PyObject* item = PySequence_GetItem(obj3, i);
33774 wxString* s = wxString_in_helper(item);
33775 if (PyErr_Occurred()) SWIG_fail;
33776 arg4->Add(*s);
33777 delete s;
33778 Py_DECREF(item);
33779 }
33780 }
33781 {
33782 PyThreadState* __tstate = wxPyBeginAllowThreads();
33783 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33784 wxPyEndAllowThreads(__tstate);
33785 if (PyErr_Occurred()) SWIG_fail;
33786 }
33787 {
33788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33789 }
33790 {
33791 if (temp4) delete arg4;
33792 }
33793 return resultobj;
33794 fail:
33795 {
33796 if (temp4) delete arg4;
33797 }
33798 return NULL;
33799 }
33800
33801
33802 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33803 PyObject *resultobj = 0;
33804 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33805 int arg2 ;
33806 int arg3 ;
33807 wxDragResult arg4 ;
33808 wxDragResult result;
33809 void *argp1 = 0 ;
33810 int res1 = 0 ;
33811 int val2 ;
33812 int ecode2 = 0 ;
33813 int val3 ;
33814 int ecode3 = 0 ;
33815 int val4 ;
33816 int ecode4 = 0 ;
33817 PyObject * obj0 = 0 ;
33818 PyObject * obj1 = 0 ;
33819 PyObject * obj2 = 0 ;
33820 PyObject * obj3 = 0 ;
33821 char * kwnames[] = {
33822 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33823 };
33824
33825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33827 if (!SWIG_IsOK(res1)) {
33828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33829 }
33830 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33831 ecode2 = SWIG_AsVal_int(obj1, &val2);
33832 if (!SWIG_IsOK(ecode2)) {
33833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33834 }
33835 arg2 = static_cast< int >(val2);
33836 ecode3 = SWIG_AsVal_int(obj2, &val3);
33837 if (!SWIG_IsOK(ecode3)) {
33838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33839 }
33840 arg3 = static_cast< int >(val3);
33841 ecode4 = SWIG_AsVal_int(obj3, &val4);
33842 if (!SWIG_IsOK(ecode4)) {
33843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33844 }
33845 arg4 = static_cast< wxDragResult >(val4);
33846 {
33847 PyThreadState* __tstate = wxPyBeginAllowThreads();
33848 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33849 wxPyEndAllowThreads(__tstate);
33850 if (PyErr_Occurred()) SWIG_fail;
33851 }
33852 resultobj = SWIG_From_int(static_cast< int >(result));
33853 return resultobj;
33854 fail:
33855 return NULL;
33856 }
33857
33858
33859 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33860 PyObject *resultobj = 0;
33861 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33862 int arg2 ;
33863 int arg3 ;
33864 wxDragResult arg4 ;
33865 wxDragResult result;
33866 void *argp1 = 0 ;
33867 int res1 = 0 ;
33868 int val2 ;
33869 int ecode2 = 0 ;
33870 int val3 ;
33871 int ecode3 = 0 ;
33872 int val4 ;
33873 int ecode4 = 0 ;
33874 PyObject * obj0 = 0 ;
33875 PyObject * obj1 = 0 ;
33876 PyObject * obj2 = 0 ;
33877 PyObject * obj3 = 0 ;
33878 char * kwnames[] = {
33879 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33880 };
33881
33882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33884 if (!SWIG_IsOK(res1)) {
33885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33886 }
33887 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33888 ecode2 = SWIG_AsVal_int(obj1, &val2);
33889 if (!SWIG_IsOK(ecode2)) {
33890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33891 }
33892 arg2 = static_cast< int >(val2);
33893 ecode3 = SWIG_AsVal_int(obj2, &val3);
33894 if (!SWIG_IsOK(ecode3)) {
33895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33896 }
33897 arg3 = static_cast< int >(val3);
33898 ecode4 = SWIG_AsVal_int(obj3, &val4);
33899 if (!SWIG_IsOK(ecode4)) {
33900 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33901 }
33902 arg4 = static_cast< wxDragResult >(val4);
33903 {
33904 PyThreadState* __tstate = wxPyBeginAllowThreads();
33905 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33906 wxPyEndAllowThreads(__tstate);
33907 if (PyErr_Occurred()) SWIG_fail;
33908 }
33909 resultobj = SWIG_From_int(static_cast< int >(result));
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33917 PyObject *resultobj = 0;
33918 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33919 void *argp1 = 0 ;
33920 int res1 = 0 ;
33921 PyObject *swig_obj[1] ;
33922
33923 if (!args) SWIG_fail;
33924 swig_obj[0] = args;
33925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33926 if (!SWIG_IsOK(res1)) {
33927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33928 }
33929 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33930 {
33931 PyThreadState* __tstate = wxPyBeginAllowThreads();
33932 (arg1)->OnLeave();
33933 wxPyEndAllowThreads(__tstate);
33934 if (PyErr_Occurred()) SWIG_fail;
33935 }
33936 resultobj = SWIG_Py_Void();
33937 return resultobj;
33938 fail:
33939 return NULL;
33940 }
33941
33942
33943 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33944 PyObject *resultobj = 0;
33945 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33946 int arg2 ;
33947 int arg3 ;
33948 bool result;
33949 void *argp1 = 0 ;
33950 int res1 = 0 ;
33951 int val2 ;
33952 int ecode2 = 0 ;
33953 int val3 ;
33954 int ecode3 = 0 ;
33955 PyObject * obj0 = 0 ;
33956 PyObject * obj1 = 0 ;
33957 PyObject * obj2 = 0 ;
33958 char * kwnames[] = {
33959 (char *) "self",(char *) "x",(char *) "y", NULL
33960 };
33961
33962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33966 }
33967 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33968 ecode2 = SWIG_AsVal_int(obj1, &val2);
33969 if (!SWIG_IsOK(ecode2)) {
33970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33971 }
33972 arg2 = static_cast< int >(val2);
33973 ecode3 = SWIG_AsVal_int(obj2, &val3);
33974 if (!SWIG_IsOK(ecode3)) {
33975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33976 }
33977 arg3 = static_cast< int >(val3);
33978 {
33979 PyThreadState* __tstate = wxPyBeginAllowThreads();
33980 result = (bool)(arg1)->OnDrop(arg2,arg3);
33981 wxPyEndAllowThreads(__tstate);
33982 if (PyErr_Occurred()) SWIG_fail;
33983 }
33984 {
33985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33986 }
33987 return resultobj;
33988 fail:
33989 return NULL;
33990 }
33991
33992
33993 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33994 PyObject *resultobj = 0;
33995 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33996 int arg2 ;
33997 int arg3 ;
33998 wxDragResult arg4 ;
33999 wxDragResult result;
34000 void *argp1 = 0 ;
34001 int res1 = 0 ;
34002 int val2 ;
34003 int ecode2 = 0 ;
34004 int val3 ;
34005 int ecode3 = 0 ;
34006 int val4 ;
34007 int ecode4 = 0 ;
34008 PyObject * obj0 = 0 ;
34009 PyObject * obj1 = 0 ;
34010 PyObject * obj2 = 0 ;
34011 PyObject * obj3 = 0 ;
34012 char * kwnames[] = {
34013 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34014 };
34015
34016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34018 if (!SWIG_IsOK(res1)) {
34019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34020 }
34021 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34022 ecode2 = SWIG_AsVal_int(obj1, &val2);
34023 if (!SWIG_IsOK(ecode2)) {
34024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34025 }
34026 arg2 = static_cast< int >(val2);
34027 ecode3 = SWIG_AsVal_int(obj2, &val3);
34028 if (!SWIG_IsOK(ecode3)) {
34029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34030 }
34031 arg3 = static_cast< int >(val3);
34032 ecode4 = SWIG_AsVal_int(obj3, &val4);
34033 if (!SWIG_IsOK(ecode4)) {
34034 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34035 }
34036 arg4 = static_cast< wxDragResult >(val4);
34037 {
34038 PyThreadState* __tstate = wxPyBeginAllowThreads();
34039 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 resultobj = SWIG_From_int(static_cast< int >(result));
34044 return resultobj;
34045 fail:
34046 return NULL;
34047 }
34048
34049
34050 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34051 PyObject *obj;
34052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34053 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
34054 return SWIG_Py_Void();
34055 }
34056
34057 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34058 return SWIG_Python_InitShadowInstance(args);
34059 }
34060
34061 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34062 PyObject *resultobj = 0;
34063 wxClipboard *result = 0 ;
34064
34065 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
34066 {
34067 PyThreadState* __tstate = wxPyBeginAllowThreads();
34068 result = (wxClipboard *)new wxClipboard();
34069 wxPyEndAllowThreads(__tstate);
34070 if (PyErr_Occurred()) SWIG_fail;
34071 }
34072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
34073 return resultobj;
34074 fail:
34075 return NULL;
34076 }
34077
34078
34079 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34080 PyObject *resultobj = 0;
34081 wxClipboard *arg1 = (wxClipboard *) 0 ;
34082 void *argp1 = 0 ;
34083 int res1 = 0 ;
34084 PyObject *swig_obj[1] ;
34085
34086 if (!args) SWIG_fail;
34087 swig_obj[0] = args;
34088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34089 if (!SWIG_IsOK(res1)) {
34090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34091 }
34092 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34093 {
34094 PyThreadState* __tstate = wxPyBeginAllowThreads();
34095 delete arg1;
34096
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 resultobj = SWIG_Py_Void();
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34108 PyObject *resultobj = 0;
34109 wxClipboard *arg1 = (wxClipboard *) 0 ;
34110 bool result;
34111 void *argp1 = 0 ;
34112 int res1 = 0 ;
34113 PyObject *swig_obj[1] ;
34114
34115 if (!args) SWIG_fail;
34116 swig_obj[0] = args;
34117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34118 if (!SWIG_IsOK(res1)) {
34119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34120 }
34121 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34122 {
34123 PyThreadState* __tstate = wxPyBeginAllowThreads();
34124 result = (bool)(arg1)->Open();
34125 wxPyEndAllowThreads(__tstate);
34126 if (PyErr_Occurred()) SWIG_fail;
34127 }
34128 {
34129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34130 }
34131 return resultobj;
34132 fail:
34133 return NULL;
34134 }
34135
34136
34137 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34138 PyObject *resultobj = 0;
34139 wxClipboard *arg1 = (wxClipboard *) 0 ;
34140 void *argp1 = 0 ;
34141 int res1 = 0 ;
34142 PyObject *swig_obj[1] ;
34143
34144 if (!args) SWIG_fail;
34145 swig_obj[0] = args;
34146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34147 if (!SWIG_IsOK(res1)) {
34148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34149 }
34150 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34151 {
34152 PyThreadState* __tstate = wxPyBeginAllowThreads();
34153 (arg1)->Close();
34154 wxPyEndAllowThreads(__tstate);
34155 if (PyErr_Occurred()) SWIG_fail;
34156 }
34157 resultobj = SWIG_Py_Void();
34158 return resultobj;
34159 fail:
34160 return NULL;
34161 }
34162
34163
34164 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34165 PyObject *resultobj = 0;
34166 wxClipboard *arg1 = (wxClipboard *) 0 ;
34167 bool result;
34168 void *argp1 = 0 ;
34169 int res1 = 0 ;
34170 PyObject *swig_obj[1] ;
34171
34172 if (!args) SWIG_fail;
34173 swig_obj[0] = args;
34174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34175 if (!SWIG_IsOK(res1)) {
34176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34177 }
34178 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34179 {
34180 PyThreadState* __tstate = wxPyBeginAllowThreads();
34181 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34182 wxPyEndAllowThreads(__tstate);
34183 if (PyErr_Occurred()) SWIG_fail;
34184 }
34185 {
34186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34187 }
34188 return resultobj;
34189 fail:
34190 return NULL;
34191 }
34192
34193
34194 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34195 PyObject *resultobj = 0;
34196 wxClipboard *arg1 = (wxClipboard *) 0 ;
34197 wxDataObject *arg2 = (wxDataObject *) 0 ;
34198 bool result;
34199 void *argp1 = 0 ;
34200 int res1 = 0 ;
34201 int res2 = 0 ;
34202 PyObject * obj0 = 0 ;
34203 PyObject * obj1 = 0 ;
34204 char * kwnames[] = {
34205 (char *) "self",(char *) "data", NULL
34206 };
34207
34208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34210 if (!SWIG_IsOK(res1)) {
34211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34212 }
34213 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34214 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34215 if (!SWIG_IsOK(res2)) {
34216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34217 }
34218 {
34219 PyThreadState* __tstate = wxPyBeginAllowThreads();
34220 result = (bool)(arg1)->AddData(arg2);
34221 wxPyEndAllowThreads(__tstate);
34222 if (PyErr_Occurred()) SWIG_fail;
34223 }
34224 {
34225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34226 }
34227 return resultobj;
34228 fail:
34229 return NULL;
34230 }
34231
34232
34233 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34234 PyObject *resultobj = 0;
34235 wxClipboard *arg1 = (wxClipboard *) 0 ;
34236 wxDataObject *arg2 = (wxDataObject *) 0 ;
34237 bool result;
34238 void *argp1 = 0 ;
34239 int res1 = 0 ;
34240 int res2 = 0 ;
34241 PyObject * obj0 = 0 ;
34242 PyObject * obj1 = 0 ;
34243 char * kwnames[] = {
34244 (char *) "self",(char *) "data", NULL
34245 };
34246
34247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34249 if (!SWIG_IsOK(res1)) {
34250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34251 }
34252 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34253 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34254 if (!SWIG_IsOK(res2)) {
34255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34256 }
34257 {
34258 PyThreadState* __tstate = wxPyBeginAllowThreads();
34259 result = (bool)(arg1)->SetData(arg2);
34260 wxPyEndAllowThreads(__tstate);
34261 if (PyErr_Occurred()) SWIG_fail;
34262 }
34263 {
34264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34265 }
34266 return resultobj;
34267 fail:
34268 return NULL;
34269 }
34270
34271
34272 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34273 PyObject *resultobj = 0;
34274 wxClipboard *arg1 = (wxClipboard *) 0 ;
34275 wxDataFormat *arg2 = 0 ;
34276 bool result;
34277 void *argp1 = 0 ;
34278 int res1 = 0 ;
34279 void *argp2 = 0 ;
34280 int res2 = 0 ;
34281 PyObject * obj0 = 0 ;
34282 PyObject * obj1 = 0 ;
34283 char * kwnames[] = {
34284 (char *) "self",(char *) "format", NULL
34285 };
34286
34287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34289 if (!SWIG_IsOK(res1)) {
34290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34291 }
34292 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34293 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34294 if (!SWIG_IsOK(res2)) {
34295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34296 }
34297 if (!argp2) {
34298 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34299 }
34300 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34301 {
34302 PyThreadState* __tstate = wxPyBeginAllowThreads();
34303 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34304 wxPyEndAllowThreads(__tstate);
34305 if (PyErr_Occurred()) SWIG_fail;
34306 }
34307 {
34308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34309 }
34310 return resultobj;
34311 fail:
34312 return NULL;
34313 }
34314
34315
34316 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34317 PyObject *resultobj = 0;
34318 wxClipboard *arg1 = (wxClipboard *) 0 ;
34319 wxDataObject *arg2 = 0 ;
34320 bool result;
34321 void *argp1 = 0 ;
34322 int res1 = 0 ;
34323 void *argp2 = 0 ;
34324 int res2 = 0 ;
34325 PyObject * obj0 = 0 ;
34326 PyObject * obj1 = 0 ;
34327 char * kwnames[] = {
34328 (char *) "self",(char *) "data", NULL
34329 };
34330
34331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34333 if (!SWIG_IsOK(res1)) {
34334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34335 }
34336 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34337 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34338 if (!SWIG_IsOK(res2)) {
34339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34340 }
34341 if (!argp2) {
34342 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34343 }
34344 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34345 {
34346 PyThreadState* __tstate = wxPyBeginAllowThreads();
34347 result = (bool)(arg1)->GetData(*arg2);
34348 wxPyEndAllowThreads(__tstate);
34349 if (PyErr_Occurred()) SWIG_fail;
34350 }
34351 {
34352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34353 }
34354 return resultobj;
34355 fail:
34356 return NULL;
34357 }
34358
34359
34360 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34361 PyObject *resultobj = 0;
34362 wxClipboard *arg1 = (wxClipboard *) 0 ;
34363 void *argp1 = 0 ;
34364 int res1 = 0 ;
34365 PyObject *swig_obj[1] ;
34366
34367 if (!args) SWIG_fail;
34368 swig_obj[0] = args;
34369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34370 if (!SWIG_IsOK(res1)) {
34371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34372 }
34373 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34374 {
34375 PyThreadState* __tstate = wxPyBeginAllowThreads();
34376 (arg1)->Clear();
34377 wxPyEndAllowThreads(__tstate);
34378 if (PyErr_Occurred()) SWIG_fail;
34379 }
34380 resultobj = SWIG_Py_Void();
34381 return resultobj;
34382 fail:
34383 return NULL;
34384 }
34385
34386
34387 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34388 PyObject *resultobj = 0;
34389 wxClipboard *arg1 = (wxClipboard *) 0 ;
34390 bool result;
34391 void *argp1 = 0 ;
34392 int res1 = 0 ;
34393 PyObject *swig_obj[1] ;
34394
34395 if (!args) SWIG_fail;
34396 swig_obj[0] = args;
34397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34398 if (!SWIG_IsOK(res1)) {
34399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34400 }
34401 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34402 {
34403 PyThreadState* __tstate = wxPyBeginAllowThreads();
34404 result = (bool)(arg1)->Flush();
34405 wxPyEndAllowThreads(__tstate);
34406 if (PyErr_Occurred()) SWIG_fail;
34407 }
34408 {
34409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34410 }
34411 return resultobj;
34412 fail:
34413 return NULL;
34414 }
34415
34416
34417 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34418 PyObject *resultobj = 0;
34419 wxClipboard *arg1 = (wxClipboard *) 0 ;
34420 bool arg2 = (bool) true ;
34421 void *argp1 = 0 ;
34422 int res1 = 0 ;
34423 bool val2 ;
34424 int ecode2 = 0 ;
34425 PyObject * obj0 = 0 ;
34426 PyObject * obj1 = 0 ;
34427 char * kwnames[] = {
34428 (char *) "self",(char *) "primary", NULL
34429 };
34430
34431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34433 if (!SWIG_IsOK(res1)) {
34434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34435 }
34436 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34437 if (obj1) {
34438 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34439 if (!SWIG_IsOK(ecode2)) {
34440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34441 }
34442 arg2 = static_cast< bool >(val2);
34443 }
34444 {
34445 PyThreadState* __tstate = wxPyBeginAllowThreads();
34446 (arg1)->UsePrimarySelection(arg2);
34447 wxPyEndAllowThreads(__tstate);
34448 if (PyErr_Occurred()) SWIG_fail;
34449 }
34450 resultobj = SWIG_Py_Void();
34451 return resultobj;
34452 fail:
34453 return NULL;
34454 }
34455
34456
34457 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34458 PyObject *resultobj = 0;
34459 wxClipboard *result = 0 ;
34460
34461 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34462 {
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 result = (wxClipboard *)wxClipboard::Get();
34465 wxPyEndAllowThreads(__tstate);
34466 if (PyErr_Occurred()) SWIG_fail;
34467 }
34468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34469 return resultobj;
34470 fail:
34471 return NULL;
34472 }
34473
34474
34475 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34476 PyObject *obj;
34477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34478 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34479 return SWIG_Py_Void();
34480 }
34481
34482 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34483 return SWIG_Python_InitShadowInstance(args);
34484 }
34485
34486 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34487 PyObject *resultobj = 0;
34488 wxClipboard *arg1 = (wxClipboard *) NULL ;
34489 wxClipboardLocker *result = 0 ;
34490 void *argp1 = 0 ;
34491 int res1 = 0 ;
34492 PyObject * obj0 = 0 ;
34493 char * kwnames[] = {
34494 (char *) "clipboard", NULL
34495 };
34496
34497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34498 if (obj0) {
34499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34500 if (!SWIG_IsOK(res1)) {
34501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34502 }
34503 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34504 }
34505 {
34506 PyThreadState* __tstate = wxPyBeginAllowThreads();
34507 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34508 wxPyEndAllowThreads(__tstate);
34509 if (PyErr_Occurred()) SWIG_fail;
34510 }
34511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34512 return resultobj;
34513 fail:
34514 return NULL;
34515 }
34516
34517
34518 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34519 PyObject *resultobj = 0;
34520 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34521 void *argp1 = 0 ;
34522 int res1 = 0 ;
34523 PyObject *swig_obj[1] ;
34524
34525 if (!args) SWIG_fail;
34526 swig_obj[0] = args;
34527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34528 if (!SWIG_IsOK(res1)) {
34529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34530 }
34531 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34532 {
34533 PyThreadState* __tstate = wxPyBeginAllowThreads();
34534 delete arg1;
34535
34536 wxPyEndAllowThreads(__tstate);
34537 if (PyErr_Occurred()) SWIG_fail;
34538 }
34539 resultobj = SWIG_Py_Void();
34540 return resultobj;
34541 fail:
34542 return NULL;
34543 }
34544
34545
34546 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34547 PyObject *resultobj = 0;
34548 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34549 bool result;
34550 void *argp1 = 0 ;
34551 int res1 = 0 ;
34552 PyObject *swig_obj[1] ;
34553
34554 if (!args) SWIG_fail;
34555 swig_obj[0] = args;
34556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34557 if (!SWIG_IsOK(res1)) {
34558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34559 }
34560 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34561 {
34562 PyThreadState* __tstate = wxPyBeginAllowThreads();
34563 result = (bool)wxClipboardLocker___nonzero__(arg1);
34564 wxPyEndAllowThreads(__tstate);
34565 if (PyErr_Occurred()) SWIG_fail;
34566 }
34567 {
34568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34569 }
34570 return resultobj;
34571 fail:
34572 return NULL;
34573 }
34574
34575
34576 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34577 PyObject *obj;
34578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34579 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34580 return SWIG_Py_Void();
34581 }
34582
34583 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34584 return SWIG_Python_InitShadowInstance(args);
34585 }
34586
34587 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34588 PyObject *resultobj = 0;
34589 int arg1 = (int) 0 ;
34590 int arg2 = (int) 0 ;
34591 int arg3 = (int) 0 ;
34592 int arg4 = (int) 0 ;
34593 wxVideoMode *result = 0 ;
34594 int val1 ;
34595 int ecode1 = 0 ;
34596 int val2 ;
34597 int ecode2 = 0 ;
34598 int val3 ;
34599 int ecode3 = 0 ;
34600 int val4 ;
34601 int ecode4 = 0 ;
34602 PyObject * obj0 = 0 ;
34603 PyObject * obj1 = 0 ;
34604 PyObject * obj2 = 0 ;
34605 PyObject * obj3 = 0 ;
34606 char * kwnames[] = {
34607 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34608 };
34609
34610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34611 if (obj0) {
34612 ecode1 = SWIG_AsVal_int(obj0, &val1);
34613 if (!SWIG_IsOK(ecode1)) {
34614 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34615 }
34616 arg1 = static_cast< int >(val1);
34617 }
34618 if (obj1) {
34619 ecode2 = SWIG_AsVal_int(obj1, &val2);
34620 if (!SWIG_IsOK(ecode2)) {
34621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34622 }
34623 arg2 = static_cast< int >(val2);
34624 }
34625 if (obj2) {
34626 ecode3 = SWIG_AsVal_int(obj2, &val3);
34627 if (!SWIG_IsOK(ecode3)) {
34628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34629 }
34630 arg3 = static_cast< int >(val3);
34631 }
34632 if (obj3) {
34633 ecode4 = SWIG_AsVal_int(obj3, &val4);
34634 if (!SWIG_IsOK(ecode4)) {
34635 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34636 }
34637 arg4 = static_cast< int >(val4);
34638 }
34639 {
34640 PyThreadState* __tstate = wxPyBeginAllowThreads();
34641 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34642 wxPyEndAllowThreads(__tstate);
34643 if (PyErr_Occurred()) SWIG_fail;
34644 }
34645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34646 return resultobj;
34647 fail:
34648 return NULL;
34649 }
34650
34651
34652 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34653 PyObject *resultobj = 0;
34654 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34655 void *argp1 = 0 ;
34656 int res1 = 0 ;
34657 PyObject *swig_obj[1] ;
34658
34659 if (!args) SWIG_fail;
34660 swig_obj[0] = args;
34661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34662 if (!SWIG_IsOK(res1)) {
34663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34664 }
34665 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34666 {
34667 PyThreadState* __tstate = wxPyBeginAllowThreads();
34668 delete arg1;
34669
34670 wxPyEndAllowThreads(__tstate);
34671 if (PyErr_Occurred()) SWIG_fail;
34672 }
34673 resultobj = SWIG_Py_Void();
34674 return resultobj;
34675 fail:
34676 return NULL;
34677 }
34678
34679
34680 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34681 PyObject *resultobj = 0;
34682 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34683 wxVideoMode *arg2 = 0 ;
34684 bool result;
34685 void *argp1 = 0 ;
34686 int res1 = 0 ;
34687 void *argp2 = 0 ;
34688 int res2 = 0 ;
34689 PyObject * obj0 = 0 ;
34690 PyObject * obj1 = 0 ;
34691 char * kwnames[] = {
34692 (char *) "self",(char *) "other", NULL
34693 };
34694
34695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34697 if (!SWIG_IsOK(res1)) {
34698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34699 }
34700 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34701 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34702 if (!SWIG_IsOK(res2)) {
34703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34704 }
34705 if (!argp2) {
34706 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34707 }
34708 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34709 {
34710 PyThreadState* __tstate = wxPyBeginAllowThreads();
34711 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34712 wxPyEndAllowThreads(__tstate);
34713 if (PyErr_Occurred()) SWIG_fail;
34714 }
34715 {
34716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34717 }
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34725 PyObject *resultobj = 0;
34726 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34727 int result;
34728 void *argp1 = 0 ;
34729 int res1 = 0 ;
34730 PyObject *swig_obj[1] ;
34731
34732 if (!args) SWIG_fail;
34733 swig_obj[0] = args;
34734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34735 if (!SWIG_IsOK(res1)) {
34736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34737 }
34738 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34739 {
34740 PyThreadState* __tstate = wxPyBeginAllowThreads();
34741 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34742 wxPyEndAllowThreads(__tstate);
34743 if (PyErr_Occurred()) SWIG_fail;
34744 }
34745 resultobj = SWIG_From_int(static_cast< int >(result));
34746 return resultobj;
34747 fail:
34748 return NULL;
34749 }
34750
34751
34752 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34753 PyObject *resultobj = 0;
34754 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34755 int result;
34756 void *argp1 = 0 ;
34757 int res1 = 0 ;
34758 PyObject *swig_obj[1] ;
34759
34760 if (!args) SWIG_fail;
34761 swig_obj[0] = args;
34762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34763 if (!SWIG_IsOK(res1)) {
34764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34765 }
34766 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34767 {
34768 PyThreadState* __tstate = wxPyBeginAllowThreads();
34769 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 resultobj = SWIG_From_int(static_cast< int >(result));
34774 return resultobj;
34775 fail:
34776 return NULL;
34777 }
34778
34779
34780 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34781 PyObject *resultobj = 0;
34782 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34783 int result;
34784 void *argp1 = 0 ;
34785 int res1 = 0 ;
34786 PyObject *swig_obj[1] ;
34787
34788 if (!args) SWIG_fail;
34789 swig_obj[0] = args;
34790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34791 if (!SWIG_IsOK(res1)) {
34792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34793 }
34794 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34795 {
34796 PyThreadState* __tstate = wxPyBeginAllowThreads();
34797 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34798 wxPyEndAllowThreads(__tstate);
34799 if (PyErr_Occurred()) SWIG_fail;
34800 }
34801 resultobj = SWIG_From_int(static_cast< int >(result));
34802 return resultobj;
34803 fail:
34804 return NULL;
34805 }
34806
34807
34808 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34809 PyObject *resultobj = 0;
34810 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34811 bool result;
34812 void *argp1 = 0 ;
34813 int res1 = 0 ;
34814 PyObject *swig_obj[1] ;
34815
34816 if (!args) SWIG_fail;
34817 swig_obj[0] = args;
34818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34819 if (!SWIG_IsOK(res1)) {
34820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34821 }
34822 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34823 {
34824 PyThreadState* __tstate = wxPyBeginAllowThreads();
34825 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34826 wxPyEndAllowThreads(__tstate);
34827 if (PyErr_Occurred()) SWIG_fail;
34828 }
34829 {
34830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34831 }
34832 return resultobj;
34833 fail:
34834 return NULL;
34835 }
34836
34837
34838 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34839 PyObject *resultobj = 0;
34840 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34841 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34842 bool result;
34843 void *argp1 = 0 ;
34844 int res1 = 0 ;
34845 void *argp2 = 0 ;
34846 int res2 = 0 ;
34847 PyObject * obj0 = 0 ;
34848 PyObject * obj1 = 0 ;
34849 char * kwnames[] = {
34850 (char *) "self",(char *) "other", NULL
34851 };
34852
34853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34855 if (!SWIG_IsOK(res1)) {
34856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34857 }
34858 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34859 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34860 if (!SWIG_IsOK(res2)) {
34861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34862 }
34863 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34864 {
34865 PyThreadState* __tstate = wxPyBeginAllowThreads();
34866 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34867 wxPyEndAllowThreads(__tstate);
34868 if (PyErr_Occurred()) SWIG_fail;
34869 }
34870 {
34871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34872 }
34873 return resultobj;
34874 fail:
34875 return NULL;
34876 }
34877
34878
34879 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34880 PyObject *resultobj = 0;
34881 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34882 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34883 bool result;
34884 void *argp1 = 0 ;
34885 int res1 = 0 ;
34886 void *argp2 = 0 ;
34887 int res2 = 0 ;
34888 PyObject * obj0 = 0 ;
34889 PyObject * obj1 = 0 ;
34890 char * kwnames[] = {
34891 (char *) "self",(char *) "other", NULL
34892 };
34893
34894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34896 if (!SWIG_IsOK(res1)) {
34897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34898 }
34899 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34900 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34901 if (!SWIG_IsOK(res2)) {
34902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34903 }
34904 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34905 {
34906 PyThreadState* __tstate = wxPyBeginAllowThreads();
34907 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34908 wxPyEndAllowThreads(__tstate);
34909 if (PyErr_Occurred()) SWIG_fail;
34910 }
34911 {
34912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34913 }
34914 return resultobj;
34915 fail:
34916 return NULL;
34917 }
34918
34919
34920 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34921 PyObject *resultobj = 0;
34922 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34923 int arg2 ;
34924 void *argp1 = 0 ;
34925 int res1 = 0 ;
34926 int val2 ;
34927 int ecode2 = 0 ;
34928 PyObject *swig_obj[2] ;
34929
34930 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34932 if (!SWIG_IsOK(res1)) {
34933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34934 }
34935 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34936 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34937 if (!SWIG_IsOK(ecode2)) {
34938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34939 }
34940 arg2 = static_cast< int >(val2);
34941 if (arg1) (arg1)->w = arg2;
34942
34943 resultobj = SWIG_Py_Void();
34944 return resultobj;
34945 fail:
34946 return NULL;
34947 }
34948
34949
34950 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34951 PyObject *resultobj = 0;
34952 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34953 int result;
34954 void *argp1 = 0 ;
34955 int res1 = 0 ;
34956 PyObject *swig_obj[1] ;
34957
34958 if (!args) SWIG_fail;
34959 swig_obj[0] = args;
34960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34961 if (!SWIG_IsOK(res1)) {
34962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34963 }
34964 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34965 result = (int) ((arg1)->w);
34966 resultobj = SWIG_From_int(static_cast< int >(result));
34967 return resultobj;
34968 fail:
34969 return NULL;
34970 }
34971
34972
34973 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34974 PyObject *resultobj = 0;
34975 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34976 int arg2 ;
34977 void *argp1 = 0 ;
34978 int res1 = 0 ;
34979 int val2 ;
34980 int ecode2 = 0 ;
34981 PyObject *swig_obj[2] ;
34982
34983 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34985 if (!SWIG_IsOK(res1)) {
34986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34987 }
34988 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34989 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34990 if (!SWIG_IsOK(ecode2)) {
34991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34992 }
34993 arg2 = static_cast< int >(val2);
34994 if (arg1) (arg1)->h = arg2;
34995
34996 resultobj = SWIG_Py_Void();
34997 return resultobj;
34998 fail:
34999 return NULL;
35000 }
35001
35002
35003 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35004 PyObject *resultobj = 0;
35005 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35006 int result;
35007 void *argp1 = 0 ;
35008 int res1 = 0 ;
35009 PyObject *swig_obj[1] ;
35010
35011 if (!args) SWIG_fail;
35012 swig_obj[0] = args;
35013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35014 if (!SWIG_IsOK(res1)) {
35015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35016 }
35017 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35018 result = (int) ((arg1)->h);
35019 resultobj = SWIG_From_int(static_cast< int >(result));
35020 return resultobj;
35021 fail:
35022 return NULL;
35023 }
35024
35025
35026 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35027 PyObject *resultobj = 0;
35028 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35029 int arg2 ;
35030 void *argp1 = 0 ;
35031 int res1 = 0 ;
35032 int val2 ;
35033 int ecode2 = 0 ;
35034 PyObject *swig_obj[2] ;
35035
35036 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
35037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35038 if (!SWIG_IsOK(res1)) {
35039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35040 }
35041 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35042 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35043 if (!SWIG_IsOK(ecode2)) {
35044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
35045 }
35046 arg2 = static_cast< int >(val2);
35047 if (arg1) (arg1)->bpp = arg2;
35048
35049 resultobj = SWIG_Py_Void();
35050 return resultobj;
35051 fail:
35052 return NULL;
35053 }
35054
35055
35056 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35057 PyObject *resultobj = 0;
35058 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35059 int result;
35060 void *argp1 = 0 ;
35061 int res1 = 0 ;
35062 PyObject *swig_obj[1] ;
35063
35064 if (!args) SWIG_fail;
35065 swig_obj[0] = args;
35066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35067 if (!SWIG_IsOK(res1)) {
35068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35069 }
35070 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35071 result = (int) ((arg1)->bpp);
35072 resultobj = SWIG_From_int(static_cast< int >(result));
35073 return resultobj;
35074 fail:
35075 return NULL;
35076 }
35077
35078
35079 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35080 PyObject *resultobj = 0;
35081 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35082 int arg2 ;
35083 void *argp1 = 0 ;
35084 int res1 = 0 ;
35085 int val2 ;
35086 int ecode2 = 0 ;
35087 PyObject *swig_obj[2] ;
35088
35089 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35091 if (!SWIG_IsOK(res1)) {
35092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35093 }
35094 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35095 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35096 if (!SWIG_IsOK(ecode2)) {
35097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35098 }
35099 arg2 = static_cast< int >(val2);
35100 if (arg1) (arg1)->refresh = arg2;
35101
35102 resultobj = SWIG_Py_Void();
35103 return resultobj;
35104 fail:
35105 return NULL;
35106 }
35107
35108
35109 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35110 PyObject *resultobj = 0;
35111 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35112 int result;
35113 void *argp1 = 0 ;
35114 int res1 = 0 ;
35115 PyObject *swig_obj[1] ;
35116
35117 if (!args) SWIG_fail;
35118 swig_obj[0] = args;
35119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35120 if (!SWIG_IsOK(res1)) {
35121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35122 }
35123 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35124 result = (int) ((arg1)->refresh);
35125 resultobj = SWIG_From_int(static_cast< int >(result));
35126 return resultobj;
35127 fail:
35128 return NULL;
35129 }
35130
35131
35132 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35133 PyObject *obj;
35134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35135 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35136 return SWIG_Py_Void();
35137 }
35138
35139 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35140 return SWIG_Python_InitShadowInstance(args);
35141 }
35142
35143 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35144 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35145 return 1;
35146 }
35147
35148
35149 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35150 PyObject *pyobj = 0;
35151
35152 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35153 return pyobj;
35154 }
35155
35156
35157 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35158 PyObject *resultobj = 0;
35159 size_t arg1 = (size_t) 0 ;
35160 wxDisplay *result = 0 ;
35161 size_t val1 ;
35162 int ecode1 = 0 ;
35163 PyObject * obj0 = 0 ;
35164 char * kwnames[] = {
35165 (char *) "index", NULL
35166 };
35167
35168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35169 if (obj0) {
35170 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35171 if (!SWIG_IsOK(ecode1)) {
35172 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35173 }
35174 arg1 = static_cast< size_t >(val1);
35175 }
35176 {
35177 PyThreadState* __tstate = wxPyBeginAllowThreads();
35178 result = (wxDisplay *)new wxDisplay(arg1);
35179 wxPyEndAllowThreads(__tstate);
35180 if (PyErr_Occurred()) SWIG_fail;
35181 }
35182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35183 return resultobj;
35184 fail:
35185 return NULL;
35186 }
35187
35188
35189 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35190 PyObject *resultobj = 0;
35191 wxDisplay *arg1 = (wxDisplay *) 0 ;
35192 void *argp1 = 0 ;
35193 int res1 = 0 ;
35194 PyObject *swig_obj[1] ;
35195
35196 if (!args) SWIG_fail;
35197 swig_obj[0] = args;
35198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35199 if (!SWIG_IsOK(res1)) {
35200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35201 }
35202 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35203 {
35204 PyThreadState* __tstate = wxPyBeginAllowThreads();
35205 delete arg1;
35206
35207 wxPyEndAllowThreads(__tstate);
35208 if (PyErr_Occurred()) SWIG_fail;
35209 }
35210 resultobj = SWIG_Py_Void();
35211 return resultobj;
35212 fail:
35213 return NULL;
35214 }
35215
35216
35217 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35218 PyObject *resultobj = 0;
35219 size_t result;
35220
35221 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35222 {
35223 PyThreadState* __tstate = wxPyBeginAllowThreads();
35224 result = (size_t)wxDisplay::GetCount();
35225 wxPyEndAllowThreads(__tstate);
35226 if (PyErr_Occurred()) SWIG_fail;
35227 }
35228 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35229 return resultobj;
35230 fail:
35231 return NULL;
35232 }
35233
35234
35235 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35236 PyObject *resultobj = 0;
35237 wxPoint *arg1 = 0 ;
35238 int result;
35239 wxPoint temp1 ;
35240 PyObject * obj0 = 0 ;
35241 char * kwnames[] = {
35242 (char *) "pt", NULL
35243 };
35244
35245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35246 {
35247 arg1 = &temp1;
35248 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35249 }
35250 {
35251 PyThreadState* __tstate = wxPyBeginAllowThreads();
35252 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35253 wxPyEndAllowThreads(__tstate);
35254 if (PyErr_Occurred()) SWIG_fail;
35255 }
35256 resultobj = SWIG_From_int(static_cast< int >(result));
35257 return resultobj;
35258 fail:
35259 return NULL;
35260 }
35261
35262
35263 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35264 PyObject *resultobj = 0;
35265 wxWindow *arg1 = (wxWindow *) 0 ;
35266 int result;
35267 void *argp1 = 0 ;
35268 int res1 = 0 ;
35269 PyObject * obj0 = 0 ;
35270 char * kwnames[] = {
35271 (char *) "window", NULL
35272 };
35273
35274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35276 if (!SWIG_IsOK(res1)) {
35277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35278 }
35279 arg1 = reinterpret_cast< wxWindow * >(argp1);
35280 {
35281 PyThreadState* __tstate = wxPyBeginAllowThreads();
35282 result = (int)wxDisplay::GetFromWindow(arg1);
35283 wxPyEndAllowThreads(__tstate);
35284 if (PyErr_Occurred()) SWIG_fail;
35285 }
35286 resultobj = SWIG_From_int(static_cast< int >(result));
35287 return resultobj;
35288 fail:
35289 return NULL;
35290 }
35291
35292
35293 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35294 PyObject *resultobj = 0;
35295 wxDisplay *arg1 = (wxDisplay *) 0 ;
35296 bool result;
35297 void *argp1 = 0 ;
35298 int res1 = 0 ;
35299 PyObject *swig_obj[1] ;
35300
35301 if (!args) SWIG_fail;
35302 swig_obj[0] = args;
35303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35304 if (!SWIG_IsOK(res1)) {
35305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35306 }
35307 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35308 {
35309 PyThreadState* __tstate = wxPyBeginAllowThreads();
35310 result = (bool)((wxDisplay const *)arg1)->IsOk();
35311 wxPyEndAllowThreads(__tstate);
35312 if (PyErr_Occurred()) SWIG_fail;
35313 }
35314 {
35315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35316 }
35317 return resultobj;
35318 fail:
35319 return NULL;
35320 }
35321
35322
35323 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35324 PyObject *resultobj = 0;
35325 wxDisplay *arg1 = (wxDisplay *) 0 ;
35326 wxRect result;
35327 void *argp1 = 0 ;
35328 int res1 = 0 ;
35329 PyObject *swig_obj[1] ;
35330
35331 if (!args) SWIG_fail;
35332 swig_obj[0] = args;
35333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35334 if (!SWIG_IsOK(res1)) {
35335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35336 }
35337 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35338 {
35339 PyThreadState* __tstate = wxPyBeginAllowThreads();
35340 result = ((wxDisplay const *)arg1)->GetGeometry();
35341 wxPyEndAllowThreads(__tstate);
35342 if (PyErr_Occurred()) SWIG_fail;
35343 }
35344 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35345 return resultobj;
35346 fail:
35347 return NULL;
35348 }
35349
35350
35351 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35352 PyObject *resultobj = 0;
35353 wxDisplay *arg1 = (wxDisplay *) 0 ;
35354 wxRect result;
35355 void *argp1 = 0 ;
35356 int res1 = 0 ;
35357 PyObject *swig_obj[1] ;
35358
35359 if (!args) SWIG_fail;
35360 swig_obj[0] = args;
35361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35362 if (!SWIG_IsOK(res1)) {
35363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35364 }
35365 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35366 {
35367 PyThreadState* __tstate = wxPyBeginAllowThreads();
35368 result = ((wxDisplay const *)arg1)->GetClientArea();
35369 wxPyEndAllowThreads(__tstate);
35370 if (PyErr_Occurred()) SWIG_fail;
35371 }
35372 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35373 return resultobj;
35374 fail:
35375 return NULL;
35376 }
35377
35378
35379 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35380 PyObject *resultobj = 0;
35381 wxDisplay *arg1 = (wxDisplay *) 0 ;
35382 wxString result;
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_wxDisplay, 0 | 0 );
35390 if (!SWIG_IsOK(res1)) {
35391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35392 }
35393 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35394 {
35395 PyThreadState* __tstate = wxPyBeginAllowThreads();
35396 result = ((wxDisplay const *)arg1)->GetName();
35397 wxPyEndAllowThreads(__tstate);
35398 if (PyErr_Occurred()) SWIG_fail;
35399 }
35400 {
35401 #if wxUSE_UNICODE
35402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35403 #else
35404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35405 #endif
35406 }
35407 return resultobj;
35408 fail:
35409 return NULL;
35410 }
35411
35412
35413 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35414 PyObject *resultobj = 0;
35415 wxDisplay *arg1 = (wxDisplay *) 0 ;
35416 bool result;
35417 void *argp1 = 0 ;
35418 int res1 = 0 ;
35419 PyObject *swig_obj[1] ;
35420
35421 if (!args) SWIG_fail;
35422 swig_obj[0] = args;
35423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35424 if (!SWIG_IsOK(res1)) {
35425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35426 }
35427 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35428 {
35429 PyThreadState* __tstate = wxPyBeginAllowThreads();
35430 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35431 wxPyEndAllowThreads(__tstate);
35432 if (PyErr_Occurred()) SWIG_fail;
35433 }
35434 {
35435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35436 }
35437 return resultobj;
35438 fail:
35439 return NULL;
35440 }
35441
35442
35443 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35444 PyObject *resultobj = 0;
35445 wxDisplay *arg1 = (wxDisplay *) 0 ;
35446 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35447 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35448 PyObject *result = 0 ;
35449 void *argp1 = 0 ;
35450 int res1 = 0 ;
35451 void *argp2 = 0 ;
35452 int res2 = 0 ;
35453 PyObject * obj0 = 0 ;
35454 PyObject * obj1 = 0 ;
35455 char * kwnames[] = {
35456 (char *) "self",(char *) "mode", NULL
35457 };
35458
35459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35461 if (!SWIG_IsOK(res1)) {
35462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35463 }
35464 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35465 if (obj1) {
35466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35467 if (!SWIG_IsOK(res2)) {
35468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35469 }
35470 if (!argp2) {
35471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35472 }
35473 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35474 }
35475 {
35476 PyThreadState* __tstate = wxPyBeginAllowThreads();
35477 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35478 wxPyEndAllowThreads(__tstate);
35479 if (PyErr_Occurred()) SWIG_fail;
35480 }
35481 resultobj = result;
35482 return resultobj;
35483 fail:
35484 return NULL;
35485 }
35486
35487
35488 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35489 PyObject *resultobj = 0;
35490 wxDisplay *arg1 = (wxDisplay *) 0 ;
35491 wxVideoMode result;
35492 void *argp1 = 0 ;
35493 int res1 = 0 ;
35494 PyObject *swig_obj[1] ;
35495
35496 if (!args) SWIG_fail;
35497 swig_obj[0] = args;
35498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35499 if (!SWIG_IsOK(res1)) {
35500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35501 }
35502 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35503 {
35504 PyThreadState* __tstate = wxPyBeginAllowThreads();
35505 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35506 wxPyEndAllowThreads(__tstate);
35507 if (PyErr_Occurred()) SWIG_fail;
35508 }
35509 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35510 return resultobj;
35511 fail:
35512 return NULL;
35513 }
35514
35515
35516 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35517 PyObject *resultobj = 0;
35518 wxDisplay *arg1 = (wxDisplay *) 0 ;
35519 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35520 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35521 bool result;
35522 void *argp1 = 0 ;
35523 int res1 = 0 ;
35524 void *argp2 = 0 ;
35525 int res2 = 0 ;
35526 PyObject * obj0 = 0 ;
35527 PyObject * obj1 = 0 ;
35528 char * kwnames[] = {
35529 (char *) "self",(char *) "mode", NULL
35530 };
35531
35532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35534 if (!SWIG_IsOK(res1)) {
35535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35536 }
35537 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35538 if (obj1) {
35539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35540 if (!SWIG_IsOK(res2)) {
35541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35542 }
35543 if (!argp2) {
35544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35545 }
35546 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35547 }
35548 {
35549 PyThreadState* __tstate = wxPyBeginAllowThreads();
35550 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35551 wxPyEndAllowThreads(__tstate);
35552 if (PyErr_Occurred()) SWIG_fail;
35553 }
35554 {
35555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35556 }
35557 return resultobj;
35558 fail:
35559 return NULL;
35560 }
35561
35562
35563 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35564 PyObject *resultobj = 0;
35565 wxDisplay *arg1 = (wxDisplay *) 0 ;
35566 void *argp1 = 0 ;
35567 int res1 = 0 ;
35568 PyObject *swig_obj[1] ;
35569
35570 if (!args) SWIG_fail;
35571 swig_obj[0] = args;
35572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35573 if (!SWIG_IsOK(res1)) {
35574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35575 }
35576 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35577 {
35578 PyThreadState* __tstate = wxPyBeginAllowThreads();
35579 wxDisplay_ResetMode(arg1);
35580 wxPyEndAllowThreads(__tstate);
35581 if (PyErr_Occurred()) SWIG_fail;
35582 }
35583 resultobj = SWIG_Py_Void();
35584 return resultobj;
35585 fail:
35586 return NULL;
35587 }
35588
35589
35590 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35591 PyObject *obj;
35592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35593 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35594 return SWIG_Py_Void();
35595 }
35596
35597 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35598 return SWIG_Python_InitShadowInstance(args);
35599 }
35600
35601 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35602 PyObject *resultobj = 0;
35603 wxStandardPaths *result = 0 ;
35604
35605 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35606 {
35607 PyThreadState* __tstate = wxPyBeginAllowThreads();
35608 result = (wxStandardPaths *)wxStandardPaths_Get();
35609 wxPyEndAllowThreads(__tstate);
35610 if (PyErr_Occurred()) SWIG_fail;
35611 }
35612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35613 return resultobj;
35614 fail:
35615 return NULL;
35616 }
35617
35618
35619 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35620 PyObject *resultobj = 0;
35621 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35622 wxString result;
35623 void *argp1 = 0 ;
35624 int res1 = 0 ;
35625 PyObject *swig_obj[1] ;
35626
35627 if (!args) SWIG_fail;
35628 swig_obj[0] = args;
35629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35630 if (!SWIG_IsOK(res1)) {
35631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35632 }
35633 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35634 {
35635 PyThreadState* __tstate = wxPyBeginAllowThreads();
35636 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35637 wxPyEndAllowThreads(__tstate);
35638 if (PyErr_Occurred()) SWIG_fail;
35639 }
35640 {
35641 #if wxUSE_UNICODE
35642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35643 #else
35644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35645 #endif
35646 }
35647 return resultobj;
35648 fail:
35649 return NULL;
35650 }
35651
35652
35653 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35654 PyObject *resultobj = 0;
35655 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35656 wxString result;
35657 void *argp1 = 0 ;
35658 int res1 = 0 ;
35659 PyObject *swig_obj[1] ;
35660
35661 if (!args) SWIG_fail;
35662 swig_obj[0] = args;
35663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35664 if (!SWIG_IsOK(res1)) {
35665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35666 }
35667 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35668 {
35669 PyThreadState* __tstate = wxPyBeginAllowThreads();
35670 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35671 wxPyEndAllowThreads(__tstate);
35672 if (PyErr_Occurred()) SWIG_fail;
35673 }
35674 {
35675 #if wxUSE_UNICODE
35676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35677 #else
35678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35679 #endif
35680 }
35681 return resultobj;
35682 fail:
35683 return NULL;
35684 }
35685
35686
35687 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35688 PyObject *resultobj = 0;
35689 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35690 wxString result;
35691 void *argp1 = 0 ;
35692 int res1 = 0 ;
35693 PyObject *swig_obj[1] ;
35694
35695 if (!args) SWIG_fail;
35696 swig_obj[0] = args;
35697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35698 if (!SWIG_IsOK(res1)) {
35699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35700 }
35701 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35702 {
35703 PyThreadState* __tstate = wxPyBeginAllowThreads();
35704 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35705 wxPyEndAllowThreads(__tstate);
35706 if (PyErr_Occurred()) SWIG_fail;
35707 }
35708 {
35709 #if wxUSE_UNICODE
35710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35711 #else
35712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35713 #endif
35714 }
35715 return resultobj;
35716 fail:
35717 return NULL;
35718 }
35719
35720
35721 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35722 PyObject *resultobj = 0;
35723 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35724 wxString result;
35725 void *argp1 = 0 ;
35726 int res1 = 0 ;
35727 PyObject *swig_obj[1] ;
35728
35729 if (!args) SWIG_fail;
35730 swig_obj[0] = args;
35731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35732 if (!SWIG_IsOK(res1)) {
35733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35734 }
35735 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35736 {
35737 PyThreadState* __tstate = wxPyBeginAllowThreads();
35738 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35739 wxPyEndAllowThreads(__tstate);
35740 if (PyErr_Occurred()) SWIG_fail;
35741 }
35742 {
35743 #if wxUSE_UNICODE
35744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35745 #else
35746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35747 #endif
35748 }
35749 return resultobj;
35750 fail:
35751 return NULL;
35752 }
35753
35754
35755 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35756 PyObject *resultobj = 0;
35757 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35758 wxString result;
35759 void *argp1 = 0 ;
35760 int res1 = 0 ;
35761 PyObject *swig_obj[1] ;
35762
35763 if (!args) SWIG_fail;
35764 swig_obj[0] = args;
35765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35766 if (!SWIG_IsOK(res1)) {
35767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35768 }
35769 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35770 {
35771 PyThreadState* __tstate = wxPyBeginAllowThreads();
35772 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35773 wxPyEndAllowThreads(__tstate);
35774 if (PyErr_Occurred()) SWIG_fail;
35775 }
35776 {
35777 #if wxUSE_UNICODE
35778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35779 #else
35780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35781 #endif
35782 }
35783 return resultobj;
35784 fail:
35785 return NULL;
35786 }
35787
35788
35789 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35790 PyObject *resultobj = 0;
35791 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35792 wxString result;
35793 void *argp1 = 0 ;
35794 int res1 = 0 ;
35795 PyObject *swig_obj[1] ;
35796
35797 if (!args) SWIG_fail;
35798 swig_obj[0] = args;
35799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35800 if (!SWIG_IsOK(res1)) {
35801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35802 }
35803 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35807 wxPyEndAllowThreads(__tstate);
35808 if (PyErr_Occurred()) SWIG_fail;
35809 }
35810 {
35811 #if wxUSE_UNICODE
35812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35813 #else
35814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35815 #endif
35816 }
35817 return resultobj;
35818 fail:
35819 return NULL;
35820 }
35821
35822
35823 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35824 PyObject *resultobj = 0;
35825 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35826 wxString result;
35827 void *argp1 = 0 ;
35828 int res1 = 0 ;
35829 PyObject *swig_obj[1] ;
35830
35831 if (!args) SWIG_fail;
35832 swig_obj[0] = args;
35833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35834 if (!SWIG_IsOK(res1)) {
35835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35836 }
35837 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35838 {
35839 PyThreadState* __tstate = wxPyBeginAllowThreads();
35840 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35841 wxPyEndAllowThreads(__tstate);
35842 if (PyErr_Occurred()) SWIG_fail;
35843 }
35844 {
35845 #if wxUSE_UNICODE
35846 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35847 #else
35848 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35849 #endif
35850 }
35851 return resultobj;
35852 fail:
35853 return NULL;
35854 }
35855
35856
35857 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35858 PyObject *resultobj = 0;
35859 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35860 wxString result;
35861 void *argp1 = 0 ;
35862 int res1 = 0 ;
35863 PyObject *swig_obj[1] ;
35864
35865 if (!args) SWIG_fail;
35866 swig_obj[0] = args;
35867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35868 if (!SWIG_IsOK(res1)) {
35869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35870 }
35871 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35872 {
35873 PyThreadState* __tstate = wxPyBeginAllowThreads();
35874 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35875 wxPyEndAllowThreads(__tstate);
35876 if (PyErr_Occurred()) SWIG_fail;
35877 }
35878 {
35879 #if wxUSE_UNICODE
35880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35881 #else
35882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35883 #endif
35884 }
35885 return resultobj;
35886 fail:
35887 return NULL;
35888 }
35889
35890
35891 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35892 PyObject *resultobj = 0;
35893 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35894 wxString *arg2 = 0 ;
35895 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35896 wxString result;
35897 void *argp1 = 0 ;
35898 int res1 = 0 ;
35899 bool temp2 = false ;
35900 int val3 ;
35901 int ecode3 = 0 ;
35902 PyObject * obj0 = 0 ;
35903 PyObject * obj1 = 0 ;
35904 PyObject * obj2 = 0 ;
35905 char * kwnames[] = {
35906 (char *) "self",(char *) "lang",(char *) "category", NULL
35907 };
35908
35909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35911 if (!SWIG_IsOK(res1)) {
35912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35913 }
35914 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35915 {
35916 arg2 = wxString_in_helper(obj1);
35917 if (arg2 == NULL) SWIG_fail;
35918 temp2 = true;
35919 }
35920 if (obj2) {
35921 ecode3 = SWIG_AsVal_int(obj2, &val3);
35922 if (!SWIG_IsOK(ecode3)) {
35923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35924 }
35925 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35926 }
35927 {
35928 PyThreadState* __tstate = wxPyBeginAllowThreads();
35929 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35930 wxPyEndAllowThreads(__tstate);
35931 if (PyErr_Occurred()) SWIG_fail;
35932 }
35933 {
35934 #if wxUSE_UNICODE
35935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35936 #else
35937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35938 #endif
35939 }
35940 {
35941 if (temp2)
35942 delete arg2;
35943 }
35944 return resultobj;
35945 fail:
35946 {
35947 if (temp2)
35948 delete arg2;
35949 }
35950 return NULL;
35951 }
35952
35953
35954 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35955 PyObject *resultobj = 0;
35956 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35957 wxString result;
35958 void *argp1 = 0 ;
35959 int res1 = 0 ;
35960 PyObject *swig_obj[1] ;
35961
35962 if (!args) SWIG_fail;
35963 swig_obj[0] = args;
35964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35965 if (!SWIG_IsOK(res1)) {
35966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35967 }
35968 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35969 {
35970 PyThreadState* __tstate = wxPyBeginAllowThreads();
35971 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35972 wxPyEndAllowThreads(__tstate);
35973 if (PyErr_Occurred()) SWIG_fail;
35974 }
35975 {
35976 #if wxUSE_UNICODE
35977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35978 #else
35979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35980 #endif
35981 }
35982 return resultobj;
35983 fail:
35984 return NULL;
35985 }
35986
35987
35988 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35989 PyObject *resultobj = 0;
35990 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35991 wxString *arg2 = 0 ;
35992 void *argp1 = 0 ;
35993 int res1 = 0 ;
35994 bool temp2 = false ;
35995 PyObject * obj0 = 0 ;
35996 PyObject * obj1 = 0 ;
35997 char * kwnames[] = {
35998 (char *) "self",(char *) "prefix", NULL
35999 };
36000
36001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
36002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36003 if (!SWIG_IsOK(res1)) {
36004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36005 }
36006 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36007 {
36008 arg2 = wxString_in_helper(obj1);
36009 if (arg2 == NULL) SWIG_fail;
36010 temp2 = true;
36011 }
36012 {
36013 PyThreadState* __tstate = wxPyBeginAllowThreads();
36014 (arg1)->SetInstallPrefix((wxString const &)*arg2);
36015 wxPyEndAllowThreads(__tstate);
36016 if (PyErr_Occurred()) SWIG_fail;
36017 }
36018 resultobj = SWIG_Py_Void();
36019 {
36020 if (temp2)
36021 delete arg2;
36022 }
36023 return resultobj;
36024 fail:
36025 {
36026 if (temp2)
36027 delete arg2;
36028 }
36029 return NULL;
36030 }
36031
36032
36033 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36034 PyObject *resultobj = 0;
36035 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36036 wxString result;
36037 void *argp1 = 0 ;
36038 int res1 = 0 ;
36039 PyObject *swig_obj[1] ;
36040
36041 if (!args) SWIG_fail;
36042 swig_obj[0] = args;
36043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36044 if (!SWIG_IsOK(res1)) {
36045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36046 }
36047 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36048 {
36049 PyThreadState* __tstate = wxPyBeginAllowThreads();
36050 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
36051 wxPyEndAllowThreads(__tstate);
36052 if (PyErr_Occurred()) SWIG_fail;
36053 }
36054 {
36055 #if wxUSE_UNICODE
36056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36057 #else
36058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36059 #endif
36060 }
36061 return resultobj;
36062 fail:
36063 return NULL;
36064 }
36065
36066
36067 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36068 PyObject *obj;
36069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36070 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
36071 return SWIG_Py_Void();
36072 }
36073
36074 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36075 PyObject *resultobj = 0;
36076 wxEventType arg1 ;
36077 wxPowerEvent *result = 0 ;
36078 int val1 ;
36079 int ecode1 = 0 ;
36080 PyObject * obj0 = 0 ;
36081 char * kwnames[] = {
36082 (char *) "evtType", NULL
36083 };
36084
36085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
36086 ecode1 = SWIG_AsVal_int(obj0, &val1);
36087 if (!SWIG_IsOK(ecode1)) {
36088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
36089 }
36090 arg1 = static_cast< wxEventType >(val1);
36091 {
36092 PyThreadState* __tstate = wxPyBeginAllowThreads();
36093 result = (wxPowerEvent *)new wxPowerEvent(arg1);
36094 wxPyEndAllowThreads(__tstate);
36095 if (PyErr_Occurred()) SWIG_fail;
36096 }
36097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
36098 return resultobj;
36099 fail:
36100 return NULL;
36101 }
36102
36103
36104 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36105 PyObject *resultobj = 0;
36106 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36107 void *argp1 = 0 ;
36108 int res1 = 0 ;
36109 PyObject *swig_obj[1] ;
36110
36111 if (!args) SWIG_fail;
36112 swig_obj[0] = args;
36113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36114 if (!SWIG_IsOK(res1)) {
36115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36116 }
36117 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36118 {
36119 PyThreadState* __tstate = wxPyBeginAllowThreads();
36120 (arg1)->Veto();
36121 wxPyEndAllowThreads(__tstate);
36122 if (PyErr_Occurred()) SWIG_fail;
36123 }
36124 resultobj = SWIG_Py_Void();
36125 return resultobj;
36126 fail:
36127 return NULL;
36128 }
36129
36130
36131 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36132 PyObject *resultobj = 0;
36133 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36134 bool result;
36135 void *argp1 = 0 ;
36136 int res1 = 0 ;
36137 PyObject *swig_obj[1] ;
36138
36139 if (!args) SWIG_fail;
36140 swig_obj[0] = args;
36141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36142 if (!SWIG_IsOK(res1)) {
36143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36144 }
36145 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36146 {
36147 PyThreadState* __tstate = wxPyBeginAllowThreads();
36148 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36149 wxPyEndAllowThreads(__tstate);
36150 if (PyErr_Occurred()) SWIG_fail;
36151 }
36152 {
36153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36154 }
36155 return resultobj;
36156 fail:
36157 return NULL;
36158 }
36159
36160
36161 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36162 PyObject *obj;
36163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36164 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36165 return SWIG_Py_Void();
36166 }
36167
36168 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36169 return SWIG_Python_InitShadowInstance(args);
36170 }
36171
36172 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36173 PyObject *resultobj = 0;
36174 wxPowerType result;
36175
36176 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36177 {
36178 PyThreadState* __tstate = wxPyBeginAllowThreads();
36179 result = (wxPowerType)wxGetPowerType();
36180 wxPyEndAllowThreads(__tstate);
36181 if (PyErr_Occurred()) SWIG_fail;
36182 }
36183 resultobj = SWIG_From_int(static_cast< int >(result));
36184 return resultobj;
36185 fail:
36186 return NULL;
36187 }
36188
36189
36190 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36191 PyObject *resultobj = 0;
36192 wxBatteryState result;
36193
36194 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36195 {
36196 PyThreadState* __tstate = wxPyBeginAllowThreads();
36197 result = (wxBatteryState)wxGetBatteryState();
36198 wxPyEndAllowThreads(__tstate);
36199 if (PyErr_Occurred()) SWIG_fail;
36200 }
36201 resultobj = SWIG_From_int(static_cast< int >(result));
36202 return resultobj;
36203 fail:
36204 return NULL;
36205 }
36206
36207
36208 static PyMethodDef SwigMethods[] = {
36209 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36210 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36211 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36212 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36213 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36214 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36215 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36216 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36217 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36218 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36219 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36220 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36221 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36222 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36223 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36224 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36225 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36226 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36227 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36228 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36229 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36230 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36231 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36232 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36233 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36234 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36235 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36236 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36237 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36238 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36239 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36240 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36241 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36242 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36243 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36244 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36245 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36246 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36247 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36248 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36249 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36250 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36251 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36252 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36253 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36254 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36255 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36256 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36257 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36258 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36259 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36260 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36261 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36262 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36263 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36264 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36265 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36266 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36267 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36268 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36269 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36270 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36271 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36272 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36273 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36274 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36275 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36277 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36278 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36279 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36280 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36281 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36282 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36283 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36285 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36287 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36288 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36289 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36290 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36291 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36292 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36293 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36294 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36295 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36296 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36297 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36298 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36299 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36300 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36301 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36302 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36304 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36305 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36306 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36307 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36308 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36309 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36310 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36311 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36312 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36313 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36314 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36315 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36316 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36317 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36318 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36320 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36321 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36322 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36323 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36324 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36325 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36326 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36327 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36328 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36329 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36330 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36331 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36332 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36333 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36334 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36335 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36336 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36337 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36338 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36341 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36342 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36343 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36344 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36345 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36346 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36347 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36348 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36349 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36350 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36351 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36352 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36353 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36354 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36355 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36356 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36357 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36358 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36359 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36360 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36362 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36363 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36364 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36365 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36366 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36368 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36370 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36371 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36375 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36376 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36377 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36378 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36379 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36380 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36381 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36383 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36384 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36386 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36387 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36388 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36389 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36390 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36391 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36392 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36393 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36394 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36395 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36396 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36397 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36398 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36399 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36400 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36402 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36403 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36404 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36405 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36407 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36408 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36409 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36410 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36411 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36412 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36413 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36414 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36415 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36416 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36417 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36418 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36419 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36420 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36421 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36422 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36423 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36424 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36425 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36426 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36427 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36429 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36430 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36431 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36432 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36433 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36434 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36436 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36437 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36438 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36439 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36440 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36441 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36442 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36443 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36444 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36445 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36447 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36448 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36449 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36450 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36451 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36452 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36453 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36454 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36455 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36457 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36458 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36459 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36460 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36461 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36462 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36463 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36464 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36465 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36466 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36468 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36469 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36470 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36472 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36473 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36474 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36475 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36476 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36477 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36478 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36479 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36480 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36481 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36482 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36483 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36485 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36486 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36487 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36488 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36490 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36491 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36492 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36494 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36495 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36496 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36497 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36498 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36499 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36500 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36501 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36502 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36503 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36504 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36505 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36506 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36507 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36508 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36509 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36510 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36511 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36512 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36513 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36514 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36515 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36516 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36517 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36518 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36519 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36520 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36521 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36523 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36524 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36525 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36526 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36527 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36528 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36529 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36530 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36534 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36535 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36536 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36537 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36538 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36539 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36540 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36541 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36542 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36543 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36545 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36546 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36547 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36548 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36549 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36550 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36551 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36552 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36553 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36554 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36555 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36556 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36557 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36558 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36559 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36560 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36561 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36562 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36563 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36564 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36565 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36566 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36567 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36568 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36569 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36570 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36571 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36572 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36573 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36574 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36576 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36577 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36578 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36579 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36580 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36581 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36582 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36583 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36584 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36585 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36588 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36589 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36590 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36591 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36592 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36593 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36595 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36596 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36597 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36599 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36600 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36601 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36602 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36603 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36604 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36606 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36607 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36608 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36609 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36611 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36612 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36613 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36614 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36615 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36616 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36617 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36618 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36619 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36620 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36621 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36622 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36623 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36624 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36625 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36626 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36627 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36628 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36629 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36630 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36631 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36632 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36633 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36634 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36635 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36636 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36637 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36638 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36639 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36640 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36641 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36642 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36644 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36645 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36646 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36649 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36650 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36651 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36655 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36656 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36657 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36658 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36659 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36660 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36661 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36662 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36663 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36666 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36667 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36668 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36669 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36670 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36672 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36673 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36674 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36676 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36677 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36678 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36679 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36680 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36681 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36682 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36683 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36684 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36685 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36686 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36687 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36688 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36689 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36690 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36691 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36692 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36693 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36700 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36702 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36703 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36704 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36706 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36707 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36709 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36710 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36711 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36712 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36714 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36715 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36716 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36717 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36718 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36719 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36720 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36721 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36722 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36723 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36724 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36725 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36726 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36727 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36728 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36731 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36732 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36733 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36734 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36735 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36736 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36737 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36738 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36739 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36742 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36743 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36744 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36745 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36746 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36752 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36753 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36758 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36759 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36761 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36762 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36763 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36764 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36765 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36766 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36770 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36771 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36772 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36773 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36774 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36775 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36776 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36777 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36778 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36779 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36780 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36781 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36782 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36783 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36784 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36785 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36786 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36787 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36788 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36789 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36790 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36793 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36794 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36797 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36798 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36799 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36803 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36804 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36805 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36809 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36810 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36811 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36814 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36820 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36821 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36824 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36825 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36826 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36827 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36828 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36831 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36832 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36834 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36835 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36836 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36837 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36838 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36839 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36841 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36842 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36843 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36844 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36845 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36846 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36847 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36848 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36849 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36850 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36852 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36853 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36854 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36856 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36857 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36858 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36859 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36860 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36861 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36862 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36863 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36864 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36865 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36866 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36867 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36868 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36869 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36870 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36871 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36872 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36873 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36874 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36875 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36877 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36878 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36879 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36880 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36881 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36882 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36883 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36884 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36885 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36886 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36887 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36888 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36889 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36890 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36891 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36892 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36893 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36894 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36895 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36896 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36898 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36899 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36900 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36902 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36903 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36904 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36905 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36906 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36907 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36908 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36909 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36910 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36911 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36912 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36913 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36914 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36915 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36916 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36917 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36918 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36919 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36920 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36921 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36922 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36923 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36924 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36925 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36926 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36927 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36928 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36929 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36930 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36931 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36932 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36933 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36934 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36935 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36936 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36937 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36938 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36939 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36940 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36941 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36942 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36943 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36944 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36945 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36946 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36947 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36948 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36949 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36950 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36951 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36952 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36953 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36954 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36955 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36956 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36957 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36958 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36959 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36960 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36961 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36962 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36963 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36964 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36965 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36966 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36967 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36968 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36969 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36970 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36971 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36972 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36973 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36974 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36975 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36976 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36977 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36978 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36979 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36980 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36981 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36982 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36983 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36984 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36985 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36986 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36987 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36988 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36989 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36990 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36991 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36992 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36993 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36994 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36995 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36996 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36997 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36998 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36999 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
37000 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
37001 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
37002 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
37003 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
37004 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
37005 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
37006 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
37007 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
37008 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
37009 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
37010 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37011 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
37012 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37013 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
37014 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37015 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37016 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
37017 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
37018 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
37019 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37020 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37021 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
37022 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
37023 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37024 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37025 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37026 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
37027 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37028 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
37029 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
37030 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
37031 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
37032 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
37033 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
37034 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37035 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
37036 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37037 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37038 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
37039 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37040 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37041 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
37042 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
37043 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
37044 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37045 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
37046 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37047 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37048 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
37049 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37050 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37051 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
37052 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
37053 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
37054 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
37055 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
37056 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
37057 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
37058 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
37059 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37060 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37061 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
37062 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
37063 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
37064 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
37065 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
37066 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
37067 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
37068 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
37069 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
37070 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
37071 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
37072 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
37073 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
37074 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
37075 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
37076 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
37077 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
37078 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
37079 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
37080 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37081 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37082 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
37083 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
37084 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
37085 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
37086 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
37087 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
37088 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
37089 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
37090 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
37091 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
37092 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
37093 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
37094 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
37095 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37096 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37097 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
37098 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
37099 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
37100 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
37101 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
37102 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
37103 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
37104 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
37105 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
37106 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
37107 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
37108 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
37109 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
37110 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
37111 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
37112 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
37113 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
37114 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
37115 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37116 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37117 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37118 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37119 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37120 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37121 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37122 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37123 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37124 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37125 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37126 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37127 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37128 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37129 { NULL, NULL, 0, NULL }
37130 };
37131
37132
37133 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37134
37135 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37136 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37137 }
37138 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37139 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37140 }
37141 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37142 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37143 }
37144 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37145 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37146 }
37147 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37148 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37149 }
37150 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37151 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37152 }
37153 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37154 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37155 }
37156 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37157 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37158 }
37159 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37160 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37161 }
37162 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37163 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37164 }
37165 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37166 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37167 }
37168 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37169 return (void *)((wxEvent *) ((wxPyEvent *) x));
37170 }
37171 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37172 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37173 }
37174 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37175 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37176 }
37177 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37178 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37179 }
37180 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37181 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37182 }
37183 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37184 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37185 }
37186 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37187 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37188 }
37189 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37190 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37191 }
37192 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37193 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37194 }
37195 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37196 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37197 }
37198 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37199 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37200 }
37201 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37202 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37203 }
37204 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37205 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37206 }
37207 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37208 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37209 }
37210 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37211 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37212 }
37213 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37214 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37215 }
37216 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37217 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37218 }
37219 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37220 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37221 }
37222 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37223 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37224 }
37225 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37226 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37227 }
37228 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37229 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37230 }
37231 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37232 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37233 }
37234 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37235 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37236 }
37237 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37238 return (void *)((wxEvent *) ((wxShowEvent *) x));
37239 }
37240 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37241 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37242 }
37243 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37244 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37245 }
37246 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37247 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37248 }
37249 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37250 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37251 }
37252 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37253 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37254 }
37255 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37256 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37257 }
37258 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37259 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37260 }
37261 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37262 return (void *)((wxConfigBase *) ((wxConfig *) x));
37263 }
37264 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37265 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37266 }
37267 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37268 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37269 }
37270 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37271 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37272 }
37273 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37274 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37275 }
37276 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37277 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37278 }
37279 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37280 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37281 }
37282 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37283 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37284 }
37285 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37286 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37287 }
37288 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37289 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37290 }
37291 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37292 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37293 }
37294 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37295 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37296 }
37297 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37298 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37299 }
37300 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37301 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37302 }
37303 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37304 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37305 }
37306 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37307 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37308 }
37309 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37310 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37311 }
37312 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37313 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37314 }
37315 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37316 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37317 }
37318 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37319 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37320 }
37321 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37322 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37323 }
37324 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37325 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37326 }
37327 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37328 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37329 }
37330 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37331 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37332 }
37333 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37334 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37335 }
37336 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37337 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37338 }
37339 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37340 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37341 }
37342 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37343 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37344 }
37345 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37346 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37347 }
37348 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37349 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37350 }
37351 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37352 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37353 }
37354 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37355 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37356 }
37357 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37358 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37359 }
37360 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37361 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37362 }
37363 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37364 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37365 }
37366 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37367 return (void *)((wxObject *) ((wxSizerItem *) x));
37368 }
37369 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37370 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37371 }
37372 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37373 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37374 }
37375 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37376 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37377 }
37378 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37379 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37380 }
37381 static void *_p_wxSizerTo_p_wxObject(void *x) {
37382 return (void *)((wxObject *) ((wxSizer *) x));
37383 }
37384 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37385 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37386 }
37387 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37388 return (void *)((wxObject *) ((wxFileHistory *) x));
37389 }
37390 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37391 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37392 }
37393 static void *_p_wxEventTo_p_wxObject(void *x) {
37394 return (void *)((wxObject *) ((wxEvent *) x));
37395 }
37396 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37397 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37398 }
37399 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37400 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37401 }
37402 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37403 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37404 }
37405 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37406 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37407 }
37408 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37409 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37410 }
37411 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37412 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37413 }
37414 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37415 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37416 }
37417 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37418 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37419 }
37420 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37421 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37422 }
37423 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37424 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37425 }
37426 static void *_p_wxControlTo_p_wxObject(void *x) {
37427 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37428 }
37429 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37430 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37431 }
37432 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37433 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37434 }
37435 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37436 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37437 }
37438 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37439 return (void *)((wxObject *) ((wxFSFile *) x));
37440 }
37441 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37442 return (void *)((wxObject *) ((wxClipboard *) x));
37443 }
37444 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37445 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37446 }
37447 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37448 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37449 }
37450 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37451 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37452 }
37453 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37454 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37455 }
37456 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37457 return (void *)((wxObject *) ((wxToolTip *) x));
37458 }
37459 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37460 return (void *)((wxObject *) ((wxMenuItem *) x));
37461 }
37462 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37463 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37464 }
37465 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37466 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37467 }
37468 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37469 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37470 }
37471 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37472 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37473 }
37474 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37475 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37476 }
37477 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37478 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37479 }
37480 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37481 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37482 }
37483 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37484 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37485 }
37486 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37487 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37488 }
37489 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37490 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37491 }
37492 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37493 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37494 }
37495 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37496 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37497 }
37498 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37499 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37500 }
37501 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37502 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37503 }
37504 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37505 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37506 }
37507 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37508 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37509 }
37510 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37511 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37512 }
37513 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37514 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37515 }
37516 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37517 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37518 }
37519 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37520 return (void *)((wxObject *) ((wxImageHandler *) x));
37521 }
37522 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37523 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37524 }
37525 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37526 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37527 }
37528 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37529 return (void *)((wxObject *) ((wxEvtHandler *) x));
37530 }
37531 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37532 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37533 }
37534 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37535 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37536 }
37537 static void *_p_wxImageTo_p_wxObject(void *x) {
37538 return (void *)((wxObject *) ((wxImage *) x));
37539 }
37540 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37541 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37542 }
37543 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37544 return (void *)((wxObject *) ((wxSystemOptions *) x));
37545 }
37546 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37547 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37548 }
37549 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37550 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37551 }
37552 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37553 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37554 }
37555 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37556 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37557 }
37558 static void *_p_wxWindowTo_p_wxObject(void *x) {
37559 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37560 }
37561 static void *_p_wxMenuTo_p_wxObject(void *x) {
37562 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37563 }
37564 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37565 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37566 }
37567 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37568 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37569 }
37570 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37571 return (void *)((wxObject *) ((wxFileSystem *) x));
37572 }
37573 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37574 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37575 }
37576 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37577 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37578 }
37579 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37580 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37581 }
37582 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37583 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37584 }
37585 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37586 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37587 }
37588 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37589 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37590 }
37591 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37592 return (void *)((wxObject *) ((wxBusyInfo *) x));
37593 }
37594 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37595 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37596 }
37597 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37598 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37599 }
37600 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37601 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37602 }
37603 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37604 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37605 }
37606 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37607 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37608 }
37609 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37610 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37611 }
37612 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37613 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37614 }
37615 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37616 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37617 }
37618 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37619 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37620 }
37621 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37622 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37623 }
37624 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37625 return (void *)((wxLog *) ((wxLogBuffer *) x));
37626 }
37627 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37628 return (void *)((wxLog *) ((wxLogStderr *) x));
37629 }
37630 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37631 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37632 }
37633 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37634 return (void *)((wxLog *) ((wxLogWindow *) x));
37635 }
37636 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37637 return (void *)((wxLog *) ((wxLogChain *) x));
37638 }
37639 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37640 return (void *)((wxLog *) ((wxLogGui *) x));
37641 }
37642 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37643 return (void *)((wxLog *) ((wxPyLog *) x));
37644 }
37645 static void *_p_wxControlTo_p_wxWindow(void *x) {
37646 return (void *)((wxWindow *) ((wxControl *) x));
37647 }
37648 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37649 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37650 }
37651 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37652 return (void *)((wxWindow *) ((wxMenuBar *) x));
37653 }
37654 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37655 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37656 }
37657 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37658 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37659 }
37660 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37661 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};
37662 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37663 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37664 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37665 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37666 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37667 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37668 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37669 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37670 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37671 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37672 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37673 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37674 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37675 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37676 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37677 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37678 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37679 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37680 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37681 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37682 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37683 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37684 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37685 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37686 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37687 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37688 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37689 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37690 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37691 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37692 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37693 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37694 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37695 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37696 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37697 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37698 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37699 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37700 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37701 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37702 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37703 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37704 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37705 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37706 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37707 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37708 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37709 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37710 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37711 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37712 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37713 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37714 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37715 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37716 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37717 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37718 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37719 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37720 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37721 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37722 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37723 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37724 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37725 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37726 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37727 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37728 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37729 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37730 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37731 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37732 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37733 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37734 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37735 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37736 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37737 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37738 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37739 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37740 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37741 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37742 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37743 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37744 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37745 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37746 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37747 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37748 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37749 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37750 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37751 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37752 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37753 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37754 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37755 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37756 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37757 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37758 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37759 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37760 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37761 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37762 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37763 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37764 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37765 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37766 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37767 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37768 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37769 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37770 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37771 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37772 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37773 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37774 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37775 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37776 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37777 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37778 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37779 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37780 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37781 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37782 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37783 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37784 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37785 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37786 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37787 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37788 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37789 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37790 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37791 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37792 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37793 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37794 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37795 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37796 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37797 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37798 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37799 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37800 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37801 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37802 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37803 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37804 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37805 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37806 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37807 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37808 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37809 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37810 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37811 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37812 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37813 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37814 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37815 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37816 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37817 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37818 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37819 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37820 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37821 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37822 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37823 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37824 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37825 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37826 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37827 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37828 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37829 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37830 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37831
37832 static swig_type_info *swig_type_initial[] = {
37833 &_swigt__p_char,
37834 &_swigt__p_form_ops_t,
37835 &_swigt__p_int,
37836 &_swigt__p_unsigned_char,
37837 &_swigt__p_unsigned_int,
37838 &_swigt__p_unsigned_long,
37839 &_swigt__p_void,
37840 &_swigt__p_wxANIHandler,
37841 &_swigt__p_wxAcceleratorTable,
37842 &_swigt__p_wxActivateEvent,
37843 &_swigt__p_wxArrayString,
37844 &_swigt__p_wxBMPHandler,
37845 &_swigt__p_wxBitmap,
37846 &_swigt__p_wxBitmapDataObject,
37847 &_swigt__p_wxBoxSizer,
37848 &_swigt__p_wxBusyCursor,
37849 &_swigt__p_wxBusyInfo,
37850 &_swigt__p_wxCURHandler,
37851 &_swigt__p_wxCaret,
37852 &_swigt__p_wxChar,
37853 &_swigt__p_wxChildFocusEvent,
37854 &_swigt__p_wxClipboard,
37855 &_swigt__p_wxClipboardLocker,
37856 &_swigt__p_wxClipboardTextEvent,
37857 &_swigt__p_wxCloseEvent,
37858 &_swigt__p_wxColour,
37859 &_swigt__p_wxCommandEvent,
37860 &_swigt__p_wxConfig,
37861 &_swigt__p_wxConfigBase,
37862 &_swigt__p_wxConfigPathChanger,
37863 &_swigt__p_wxContextMenuEvent,
37864 &_swigt__p_wxControl,
37865 &_swigt__p_wxControlWithItems,
37866 &_swigt__p_wxCursor,
37867 &_swigt__p_wxCustomDataObject,
37868 &_swigt__p_wxDC,
37869 &_swigt__p_wxDataFormat,
37870 &_swigt__p_wxDataObject,
37871 &_swigt__p_wxDataObjectComposite,
37872 &_swigt__p_wxDataObjectSimple,
37873 &_swigt__p_wxDateEvent,
37874 &_swigt__p_wxDateSpan,
37875 &_swigt__p_wxDateTime,
37876 &_swigt__p_wxDateTime__TimeZone,
37877 &_swigt__p_wxDisplay,
37878 &_swigt__p_wxDisplayChangedEvent,
37879 &_swigt__p_wxDropFilesEvent,
37880 &_swigt__p_wxDuplexMode,
37881 &_swigt__p_wxEraseEvent,
37882 &_swigt__p_wxEvent,
37883 &_swigt__p_wxEvtHandler,
37884 &_swigt__p_wxFSFile,
37885 &_swigt__p_wxFileConfig,
37886 &_swigt__p_wxFileDataObject,
37887 &_swigt__p_wxFileHistory,
37888 &_swigt__p_wxFileSystem,
37889 &_swigt__p_wxFileType,
37890 &_swigt__p_wxFileTypeInfo,
37891 &_swigt__p_wxFlexGridSizer,
37892 &_swigt__p_wxFocusEvent,
37893 &_swigt__p_wxFont,
37894 &_swigt__p_wxFrame,
37895 &_swigt__p_wxGBSizerItem,
37896 &_swigt__p_wxGIFHandler,
37897 &_swigt__p_wxGridBagSizer,
37898 &_swigt__p_wxGridSizer,
37899 &_swigt__p_wxICOHandler,
37900 &_swigt__p_wxIcon,
37901 &_swigt__p_wxIconizeEvent,
37902 &_swigt__p_wxIdleEvent,
37903 &_swigt__p_wxImage,
37904 &_swigt__p_wxImageHandler,
37905 &_swigt__p_wxIndividualLayoutConstraint,
37906 &_swigt__p_wxInitDialogEvent,
37907 &_swigt__p_wxJPEGHandler,
37908 &_swigt__p_wxJoystick,
37909 &_swigt__p_wxJoystickEvent,
37910 &_swigt__p_wxKeyEvent,
37911 &_swigt__p_wxKillError,
37912 &_swigt__p_wxLayoutConstraints,
37913 &_swigt__p_wxLog,
37914 &_swigt__p_wxLogBuffer,
37915 &_swigt__p_wxLogChain,
37916 &_swigt__p_wxLogGui,
37917 &_swigt__p_wxLogNull,
37918 &_swigt__p_wxLogStderr,
37919 &_swigt__p_wxLogTextCtrl,
37920 &_swigt__p_wxLogWindow,
37921 &_swigt__p_wxMaximizeEvent,
37922 &_swigt__p_wxMemorySize,
37923 &_swigt__p_wxMenu,
37924 &_swigt__p_wxMenuBar,
37925 &_swigt__p_wxMenuEvent,
37926 &_swigt__p_wxMenuItem,
37927 &_swigt__p_wxMetafileDataObject,
37928 &_swigt__p_wxMimeTypesManager,
37929 &_swigt__p_wxMouseCaptureChangedEvent,
37930 &_swigt__p_wxMouseEvent,
37931 &_swigt__p_wxMouseState,
37932 &_swigt__p_wxMoveEvent,
37933 &_swigt__p_wxMutexGuiLocker,
37934 &_swigt__p_wxNavigationKeyEvent,
37935 &_swigt__p_wxNcPaintEvent,
37936 &_swigt__p_wxNotifyEvent,
37937 &_swigt__p_wxObject,
37938 &_swigt__p_wxOutputStream,
37939 &_swigt__p_wxPCXHandler,
37940 &_swigt__p_wxPNGHandler,
37941 &_swigt__p_wxPNMHandler,
37942 &_swigt__p_wxPaintEvent,
37943 &_swigt__p_wxPaletteChangedEvent,
37944 &_swigt__p_wxPaperSize,
37945 &_swigt__p_wxPoint,
37946 &_swigt__p_wxPowerEvent,
37947 &_swigt__p_wxProcessEvent,
37948 &_swigt__p_wxPyApp,
37949 &_swigt__p_wxPyArtProvider,
37950 &_swigt__p_wxPyBitmapDataObject,
37951 &_swigt__p_wxPyCommandEvent,
37952 &_swigt__p_wxPyDataObjectSimple,
37953 &_swigt__p_wxPyDropSource,
37954 &_swigt__p_wxPyDropTarget,
37955 &_swigt__p_wxPyEvent,
37956 &_swigt__p_wxPyFileDropTarget,
37957 &_swigt__p_wxPyImageHandler,
37958 &_swigt__p_wxPyLog,
37959 &_swigt__p_wxPyProcess,
37960 &_swigt__p_wxPySizer,
37961 &_swigt__p_wxPyTextDataObject,
37962 &_swigt__p_wxPyTextDropTarget,
37963 &_swigt__p_wxPyTimer,
37964 &_swigt__p_wxPyTipProvider,
37965 &_swigt__p_wxPyValidator,
37966 &_swigt__p_wxQueryNewPaletteEvent,
37967 &_swigt__p_wxRect,
37968 &_swigt__p_wxScrollEvent,
37969 &_swigt__p_wxScrollWinEvent,
37970 &_swigt__p_wxSetCursorEvent,
37971 &_swigt__p_wxShowEvent,
37972 &_swigt__p_wxSingleInstanceChecker,
37973 &_swigt__p_wxSize,
37974 &_swigt__p_wxSizeEvent,
37975 &_swigt__p_wxSizer,
37976 &_swigt__p_wxSizerItem,
37977 &_swigt__p_wxSound,
37978 &_swigt__p_wxStandardPaths,
37979 &_swigt__p_wxStaticBoxSizer,
37980 &_swigt__p_wxStdDialogButtonSizer,
37981 &_swigt__p_wxStopWatch,
37982 &_swigt__p_wxString,
37983 &_swigt__p_wxSysColourChangedEvent,
37984 &_swigt__p_wxSystemOptions,
37985 &_swigt__p_wxSystemSettings,
37986 &_swigt__p_wxTIFFHandler,
37987 &_swigt__p_wxTextCtrl,
37988 &_swigt__p_wxTextDataObject,
37989 &_swigt__p_wxTimeSpan,
37990 &_swigt__p_wxTimer,
37991 &_swigt__p_wxTimerEvent,
37992 &_swigt__p_wxTimerRunner,
37993 &_swigt__p_wxTipProvider,
37994 &_swigt__p_wxToolTip,
37995 &_swigt__p_wxURLDataObject,
37996 &_swigt__p_wxUpdateUIEvent,
37997 &_swigt__p_wxValidator,
37998 &_swigt__p_wxVideoMode,
37999 &_swigt__p_wxWindow,
38000 &_swigt__p_wxWindowCreateEvent,
38001 &_swigt__p_wxWindowDestroyEvent,
38002 &_swigt__p_wxWindowDisabler,
38003 &_swigt__p_wxXPMHandler,
38004 };
38005
38006 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
38007 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
38008 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
38009 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
38010 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
38011 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
38012 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
38013 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
38014 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
38015 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}};
38016 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
38017 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
38018 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
38019 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
38020 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
38021 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
38022 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
38023 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
38024 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}};
38025 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
38026 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
38027 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
38028 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
38029 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
38030 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}};
38031 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
38032 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}};
38033 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
38034 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
38035 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
38036 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
38037 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
38038 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38039 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38040 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
38041 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
38042 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
38043 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
38044 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
38045 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
38046 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
38047 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
38048 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
38049 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
38050 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
38051 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38052 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38053 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
38054 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38055 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
38056 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
38057 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
38058 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38059 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38060 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
38061 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38062 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38063 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38064 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38065 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
38066 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38067 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38068 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
38069 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38070 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38071 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
38072 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38073 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38074 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
38075 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_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_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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}};
38076 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
38077 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
38078 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
38079 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
38080 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
38081 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
38082 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
38083 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
38084 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38085 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
38086 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
38087 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
38088 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
38089 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
38090 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
38091 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
38092 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
38093 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
38094 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}};
38095 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
38096 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
38097 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
38098 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
38099 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
38100 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38101 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
38102 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
38103 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
38104 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38105 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
38106 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
38107 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
38108 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
38109 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38110 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38111 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
38112 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38113 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38114 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
38115 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38116 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38117 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38118 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38119 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38120 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38121 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38122 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38123 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38124 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38125 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38126 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38127 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38128 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38129 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38130 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38131 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38132 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38133 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38134 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38135 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38136 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38137 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38138 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_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}};
38139 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38140 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38141 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38142 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38143 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38144 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38145 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38146 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38147 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38148 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}};
38149 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38150 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38151 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38152 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38153 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38154 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38155 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38156 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38157 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38158 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38159 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38160 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38161 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38162 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38163 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38164 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38165 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38166 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}};
38167 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38168 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38169 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38170 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38171 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}};
38172 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38173 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38174 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38175 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}};
38176 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38177
38178 static swig_cast_info *swig_cast_initial[] = {
38179 _swigc__p_char,
38180 _swigc__p_form_ops_t,
38181 _swigc__p_int,
38182 _swigc__p_unsigned_char,
38183 _swigc__p_unsigned_int,
38184 _swigc__p_unsigned_long,
38185 _swigc__p_void,
38186 _swigc__p_wxANIHandler,
38187 _swigc__p_wxAcceleratorTable,
38188 _swigc__p_wxActivateEvent,
38189 _swigc__p_wxArrayString,
38190 _swigc__p_wxBMPHandler,
38191 _swigc__p_wxBitmap,
38192 _swigc__p_wxBitmapDataObject,
38193 _swigc__p_wxBoxSizer,
38194 _swigc__p_wxBusyCursor,
38195 _swigc__p_wxBusyInfo,
38196 _swigc__p_wxCURHandler,
38197 _swigc__p_wxCaret,
38198 _swigc__p_wxChar,
38199 _swigc__p_wxChildFocusEvent,
38200 _swigc__p_wxClipboard,
38201 _swigc__p_wxClipboardLocker,
38202 _swigc__p_wxClipboardTextEvent,
38203 _swigc__p_wxCloseEvent,
38204 _swigc__p_wxColour,
38205 _swigc__p_wxCommandEvent,
38206 _swigc__p_wxConfig,
38207 _swigc__p_wxConfigBase,
38208 _swigc__p_wxConfigPathChanger,
38209 _swigc__p_wxContextMenuEvent,
38210 _swigc__p_wxControl,
38211 _swigc__p_wxControlWithItems,
38212 _swigc__p_wxCursor,
38213 _swigc__p_wxCustomDataObject,
38214 _swigc__p_wxDC,
38215 _swigc__p_wxDataFormat,
38216 _swigc__p_wxDataObject,
38217 _swigc__p_wxDataObjectComposite,
38218 _swigc__p_wxDataObjectSimple,
38219 _swigc__p_wxDateEvent,
38220 _swigc__p_wxDateSpan,
38221 _swigc__p_wxDateTime,
38222 _swigc__p_wxDateTime__TimeZone,
38223 _swigc__p_wxDisplay,
38224 _swigc__p_wxDisplayChangedEvent,
38225 _swigc__p_wxDropFilesEvent,
38226 _swigc__p_wxDuplexMode,
38227 _swigc__p_wxEraseEvent,
38228 _swigc__p_wxEvent,
38229 _swigc__p_wxEvtHandler,
38230 _swigc__p_wxFSFile,
38231 _swigc__p_wxFileConfig,
38232 _swigc__p_wxFileDataObject,
38233 _swigc__p_wxFileHistory,
38234 _swigc__p_wxFileSystem,
38235 _swigc__p_wxFileType,
38236 _swigc__p_wxFileTypeInfo,
38237 _swigc__p_wxFlexGridSizer,
38238 _swigc__p_wxFocusEvent,
38239 _swigc__p_wxFont,
38240 _swigc__p_wxFrame,
38241 _swigc__p_wxGBSizerItem,
38242 _swigc__p_wxGIFHandler,
38243 _swigc__p_wxGridBagSizer,
38244 _swigc__p_wxGridSizer,
38245 _swigc__p_wxICOHandler,
38246 _swigc__p_wxIcon,
38247 _swigc__p_wxIconizeEvent,
38248 _swigc__p_wxIdleEvent,
38249 _swigc__p_wxImage,
38250 _swigc__p_wxImageHandler,
38251 _swigc__p_wxIndividualLayoutConstraint,
38252 _swigc__p_wxInitDialogEvent,
38253 _swigc__p_wxJPEGHandler,
38254 _swigc__p_wxJoystick,
38255 _swigc__p_wxJoystickEvent,
38256 _swigc__p_wxKeyEvent,
38257 _swigc__p_wxKillError,
38258 _swigc__p_wxLayoutConstraints,
38259 _swigc__p_wxLog,
38260 _swigc__p_wxLogBuffer,
38261 _swigc__p_wxLogChain,
38262 _swigc__p_wxLogGui,
38263 _swigc__p_wxLogNull,
38264 _swigc__p_wxLogStderr,
38265 _swigc__p_wxLogTextCtrl,
38266 _swigc__p_wxLogWindow,
38267 _swigc__p_wxMaximizeEvent,
38268 _swigc__p_wxMemorySize,
38269 _swigc__p_wxMenu,
38270 _swigc__p_wxMenuBar,
38271 _swigc__p_wxMenuEvent,
38272 _swigc__p_wxMenuItem,
38273 _swigc__p_wxMetafileDataObject,
38274 _swigc__p_wxMimeTypesManager,
38275 _swigc__p_wxMouseCaptureChangedEvent,
38276 _swigc__p_wxMouseEvent,
38277 _swigc__p_wxMouseState,
38278 _swigc__p_wxMoveEvent,
38279 _swigc__p_wxMutexGuiLocker,
38280 _swigc__p_wxNavigationKeyEvent,
38281 _swigc__p_wxNcPaintEvent,
38282 _swigc__p_wxNotifyEvent,
38283 _swigc__p_wxObject,
38284 _swigc__p_wxOutputStream,
38285 _swigc__p_wxPCXHandler,
38286 _swigc__p_wxPNGHandler,
38287 _swigc__p_wxPNMHandler,
38288 _swigc__p_wxPaintEvent,
38289 _swigc__p_wxPaletteChangedEvent,
38290 _swigc__p_wxPaperSize,
38291 _swigc__p_wxPoint,
38292 _swigc__p_wxPowerEvent,
38293 _swigc__p_wxProcessEvent,
38294 _swigc__p_wxPyApp,
38295 _swigc__p_wxPyArtProvider,
38296 _swigc__p_wxPyBitmapDataObject,
38297 _swigc__p_wxPyCommandEvent,
38298 _swigc__p_wxPyDataObjectSimple,
38299 _swigc__p_wxPyDropSource,
38300 _swigc__p_wxPyDropTarget,
38301 _swigc__p_wxPyEvent,
38302 _swigc__p_wxPyFileDropTarget,
38303 _swigc__p_wxPyImageHandler,
38304 _swigc__p_wxPyLog,
38305 _swigc__p_wxPyProcess,
38306 _swigc__p_wxPySizer,
38307 _swigc__p_wxPyTextDataObject,
38308 _swigc__p_wxPyTextDropTarget,
38309 _swigc__p_wxPyTimer,
38310 _swigc__p_wxPyTipProvider,
38311 _swigc__p_wxPyValidator,
38312 _swigc__p_wxQueryNewPaletteEvent,
38313 _swigc__p_wxRect,
38314 _swigc__p_wxScrollEvent,
38315 _swigc__p_wxScrollWinEvent,
38316 _swigc__p_wxSetCursorEvent,
38317 _swigc__p_wxShowEvent,
38318 _swigc__p_wxSingleInstanceChecker,
38319 _swigc__p_wxSize,
38320 _swigc__p_wxSizeEvent,
38321 _swigc__p_wxSizer,
38322 _swigc__p_wxSizerItem,
38323 _swigc__p_wxSound,
38324 _swigc__p_wxStandardPaths,
38325 _swigc__p_wxStaticBoxSizer,
38326 _swigc__p_wxStdDialogButtonSizer,
38327 _swigc__p_wxStopWatch,
38328 _swigc__p_wxString,
38329 _swigc__p_wxSysColourChangedEvent,
38330 _swigc__p_wxSystemOptions,
38331 _swigc__p_wxSystemSettings,
38332 _swigc__p_wxTIFFHandler,
38333 _swigc__p_wxTextCtrl,
38334 _swigc__p_wxTextDataObject,
38335 _swigc__p_wxTimeSpan,
38336 _swigc__p_wxTimer,
38337 _swigc__p_wxTimerEvent,
38338 _swigc__p_wxTimerRunner,
38339 _swigc__p_wxTipProvider,
38340 _swigc__p_wxToolTip,
38341 _swigc__p_wxURLDataObject,
38342 _swigc__p_wxUpdateUIEvent,
38343 _swigc__p_wxValidator,
38344 _swigc__p_wxVideoMode,
38345 _swigc__p_wxWindow,
38346 _swigc__p_wxWindowCreateEvent,
38347 _swigc__p_wxWindowDestroyEvent,
38348 _swigc__p_wxWindowDisabler,
38349 _swigc__p_wxXPMHandler,
38350 };
38351
38352
38353 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38354
38355 static swig_const_info swig_const_table[] = {
38356 {0, 0, 0, 0.0, 0, 0}};
38357
38358 #ifdef __cplusplus
38359 }
38360 #endif
38361 /* -----------------------------------------------------------------------------
38362 * Type initialization:
38363 * This problem is tough by the requirement that no dynamic
38364 * memory is used. Also, since swig_type_info structures store pointers to
38365 * swig_cast_info structures and swig_cast_info structures store pointers back
38366 * to swig_type_info structures, we need some lookup code at initialization.
38367 * The idea is that swig generates all the structures that are needed.
38368 * The runtime then collects these partially filled structures.
38369 * The SWIG_InitializeModule function takes these initial arrays out of
38370 * swig_module, and does all the lookup, filling in the swig_module.types
38371 * array with the correct data and linking the correct swig_cast_info
38372 * structures together.
38373 *
38374 * The generated swig_type_info structures are assigned staticly to an initial
38375 * array. We just loop though that array, and handle each type individually.
38376 * First we lookup if this type has been already loaded, and if so, use the
38377 * loaded structure instead of the generated one. Then we have to fill in the
38378 * cast linked list. The cast data is initially stored in something like a
38379 * two-dimensional array. Each row corresponds to a type (there are the same
38380 * number of rows as there are in the swig_type_initial array). Each entry in
38381 * a column is one of the swig_cast_info structures for that type.
38382 * The cast_initial array is actually an array of arrays, because each row has
38383 * a variable number of columns. So to actually build the cast linked list,
38384 * we find the array of casts associated with the type, and loop through it
38385 * adding the casts to the list. The one last trick we need to do is making
38386 * sure the type pointer in the swig_cast_info struct is correct.
38387 *
38388 * First off, we lookup the cast->type name to see if it is already loaded.
38389 * There are three cases to handle:
38390 * 1) If the cast->type has already been loaded AND the type we are adding
38391 * casting info to has not been loaded (it is in this module), THEN we
38392 * replace the cast->type pointer with the type pointer that has already
38393 * been loaded.
38394 * 2) If BOTH types (the one we are adding casting info to, and the
38395 * cast->type) are loaded, THEN the cast info has already been loaded by
38396 * the previous module so we just ignore it.
38397 * 3) Finally, if cast->type has not already been loaded, then we add that
38398 * swig_cast_info to the linked list (because the cast->type) pointer will
38399 * be correct.
38400 * ----------------------------------------------------------------------------- */
38401
38402 #ifdef __cplusplus
38403 extern "C" {
38404 #if 0
38405 } /* c-mode */
38406 #endif
38407 #endif
38408
38409 #if 0
38410 #define SWIGRUNTIME_DEBUG
38411 #endif
38412
38413 SWIGRUNTIME void
38414 SWIG_InitializeModule(void *clientdata) {
38415 size_t i;
38416 swig_module_info *module_head;
38417 static int init_run = 0;
38418
38419 clientdata = clientdata;
38420
38421 if (init_run) return;
38422 init_run = 1;
38423
38424 /* Initialize the swig_module */
38425 swig_module.type_initial = swig_type_initial;
38426 swig_module.cast_initial = swig_cast_initial;
38427
38428 /* Try and load any already created modules */
38429 module_head = SWIG_GetModule(clientdata);
38430 if (module_head) {
38431 swig_module.next = module_head->next;
38432 module_head->next = &swig_module;
38433 } else {
38434 /* This is the first module loaded */
38435 swig_module.next = &swig_module;
38436 SWIG_SetModule(clientdata, &swig_module);
38437 }
38438
38439 /* Now work on filling in swig_module.types */
38440 #ifdef SWIGRUNTIME_DEBUG
38441 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38442 #endif
38443 for (i = 0; i < swig_module.size; ++i) {
38444 swig_type_info *type = 0;
38445 swig_type_info *ret;
38446 swig_cast_info *cast;
38447
38448 #ifdef SWIGRUNTIME_DEBUG
38449 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38450 #endif
38451
38452 /* if there is another module already loaded */
38453 if (swig_module.next != &swig_module) {
38454 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38455 }
38456 if (type) {
38457 /* Overwrite clientdata field */
38458 #ifdef SWIGRUNTIME_DEBUG
38459 printf("SWIG_InitializeModule: found type %s\n", type->name);
38460 #endif
38461 if (swig_module.type_initial[i]->clientdata) {
38462 type->clientdata = swig_module.type_initial[i]->clientdata;
38463 #ifdef SWIGRUNTIME_DEBUG
38464 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38465 #endif
38466 }
38467 } else {
38468 type = swig_module.type_initial[i];
38469 }
38470
38471 /* Insert casting types */
38472 cast = swig_module.cast_initial[i];
38473 while (cast->type) {
38474 /* Don't need to add information already in the list */
38475 ret = 0;
38476 #ifdef SWIGRUNTIME_DEBUG
38477 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38478 #endif
38479 if (swig_module.next != &swig_module) {
38480 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38481 #ifdef SWIGRUNTIME_DEBUG
38482 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38483 #endif
38484 }
38485 if (ret) {
38486 if (type == swig_module.type_initial[i]) {
38487 #ifdef SWIGRUNTIME_DEBUG
38488 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38489 #endif
38490 cast->type = ret;
38491 ret = 0;
38492 } else {
38493 /* Check for casting already in the list */
38494 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38495 #ifdef SWIGRUNTIME_DEBUG
38496 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38497 #endif
38498 if (!ocast) ret = 0;
38499 }
38500 }
38501
38502 if (!ret) {
38503 #ifdef SWIGRUNTIME_DEBUG
38504 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38505 #endif
38506 if (type->cast) {
38507 type->cast->prev = cast;
38508 cast->next = type->cast;
38509 }
38510 type->cast = cast;
38511 }
38512 cast++;
38513 }
38514 /* Set entry in modules->types array equal to the type */
38515 swig_module.types[i] = type;
38516 }
38517 swig_module.types[i] = 0;
38518
38519 #ifdef SWIGRUNTIME_DEBUG
38520 printf("**** SWIG_InitializeModule: Cast List ******\n");
38521 for (i = 0; i < swig_module.size; ++i) {
38522 int j = 0;
38523 swig_cast_info *cast = swig_module.cast_initial[i];
38524 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38525 while (cast->type) {
38526 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38527 cast++;
38528 ++j;
38529 }
38530 printf("---- Total casts: %d\n",j);
38531 }
38532 printf("**** SWIG_InitializeModule: Cast List ******\n");
38533 #endif
38534 }
38535
38536 /* This function will propagate the clientdata field of type to
38537 * any new swig_type_info structures that have been added into the list
38538 * of equivalent types. It is like calling
38539 * SWIG_TypeClientData(type, clientdata) a second time.
38540 */
38541 SWIGRUNTIME void
38542 SWIG_PropagateClientData(void) {
38543 size_t i;
38544 swig_cast_info *equiv;
38545 static int init_run = 0;
38546
38547 if (init_run) return;
38548 init_run = 1;
38549
38550 for (i = 0; i < swig_module.size; i++) {
38551 if (swig_module.types[i]->clientdata) {
38552 equiv = swig_module.types[i]->cast;
38553 while (equiv) {
38554 if (!equiv->converter) {
38555 if (equiv->type && !equiv->type->clientdata)
38556 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38557 }
38558 equiv = equiv->next;
38559 }
38560 }
38561 }
38562 }
38563
38564 #ifdef __cplusplus
38565 #if 0
38566 {
38567 /* c-mode */
38568 #endif
38569 }
38570 #endif
38571
38572
38573
38574 #ifdef __cplusplus
38575 extern "C" {
38576 #endif
38577
38578 /* Python-specific SWIG API */
38579 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38580 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38581 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38582
38583 /* -----------------------------------------------------------------------------
38584 * global variable support code.
38585 * ----------------------------------------------------------------------------- */
38586
38587 typedef struct swig_globalvar {
38588 char *name; /* Name of global variable */
38589 PyObject *(*get_attr)(void); /* Return the current value */
38590 int (*set_attr)(PyObject *); /* Set the value */
38591 struct swig_globalvar *next;
38592 } swig_globalvar;
38593
38594 typedef struct swig_varlinkobject {
38595 PyObject_HEAD
38596 swig_globalvar *vars;
38597 } swig_varlinkobject;
38598
38599 SWIGINTERN PyObject *
38600 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38601 return PyString_FromString("<Swig global variables>");
38602 }
38603
38604 SWIGINTERN PyObject *
38605 swig_varlink_str(swig_varlinkobject *v) {
38606 PyObject *str = PyString_FromString("(");
38607 swig_globalvar *var;
38608 for (var = v->vars; var; var=var->next) {
38609 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38610 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38611 }
38612 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38613 return str;
38614 }
38615
38616 SWIGINTERN int
38617 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38618 PyObject *str = swig_varlink_str(v);
38619 fprintf(fp,"Swig global variables ");
38620 fprintf(fp,"%s\n", PyString_AsString(str));
38621 Py_DECREF(str);
38622 return 0;
38623 }
38624
38625 SWIGINTERN void
38626 swig_varlink_dealloc(swig_varlinkobject *v) {
38627 swig_globalvar *var = v->vars;
38628 while (var) {
38629 swig_globalvar *n = var->next;
38630 free(var->name);
38631 free(var);
38632 var = n;
38633 }
38634 }
38635
38636 SWIGINTERN PyObject *
38637 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38638 PyObject *res = NULL;
38639 swig_globalvar *var = v->vars;
38640 while (var) {
38641 if (strcmp(var->name,n) == 0) {
38642 res = (*var->get_attr)();
38643 break;
38644 }
38645 var = var->next;
38646 }
38647 if (res == NULL && !PyErr_Occurred()) {
38648 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38649 }
38650 return res;
38651 }
38652
38653 SWIGINTERN int
38654 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38655 int res = 1;
38656 swig_globalvar *var = v->vars;
38657 while (var) {
38658 if (strcmp(var->name,n) == 0) {
38659 res = (*var->set_attr)(p);
38660 break;
38661 }
38662 var = var->next;
38663 }
38664 if (res == 1 && !PyErr_Occurred()) {
38665 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38666 }
38667 return res;
38668 }
38669
38670 SWIGINTERN PyTypeObject*
38671 swig_varlink_type(void) {
38672 static char varlink__doc__[] = "Swig var link object";
38673 static PyTypeObject varlink_type;
38674 static int type_init = 0;
38675 if (!type_init) {
38676 const PyTypeObject tmp
38677 = {
38678 PyObject_HEAD_INIT(NULL)
38679 0, /* Number of items in variable part (ob_size) */
38680 (char *)"swigvarlink", /* Type name (tp_name) */
38681 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38682 0, /* Itemsize (tp_itemsize) */
38683 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38684 (printfunc) swig_varlink_print, /* Print (tp_print) */
38685 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38686 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38687 0, /* tp_compare */
38688 (reprfunc) swig_varlink_repr, /* tp_repr */
38689 0, /* tp_as_number */
38690 0, /* tp_as_sequence */
38691 0, /* tp_as_mapping */
38692 0, /* tp_hash */
38693 0, /* tp_call */
38694 (reprfunc)swig_varlink_str, /* tp_str */
38695 0, /* tp_getattro */
38696 0, /* tp_setattro */
38697 0, /* tp_as_buffer */
38698 0, /* tp_flags */
38699 varlink__doc__, /* tp_doc */
38700 0, /* tp_traverse */
38701 0, /* tp_clear */
38702 0, /* tp_richcompare */
38703 0, /* tp_weaklistoffset */
38704 #if PY_VERSION_HEX >= 0x02020000
38705 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38706 #endif
38707 #if PY_VERSION_HEX >= 0x02030000
38708 0, /* tp_del */
38709 #endif
38710 #ifdef COUNT_ALLOCS
38711 0,0,0,0 /* tp_alloc -> tp_next */
38712 #endif
38713 };
38714 varlink_type = tmp;
38715 varlink_type.ob_type = &PyType_Type;
38716 type_init = 1;
38717 }
38718 return &varlink_type;
38719 }
38720
38721 /* Create a variable linking object for use later */
38722 SWIGINTERN PyObject *
38723 SWIG_Python_newvarlink(void) {
38724 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38725 if (result) {
38726 result->vars = 0;
38727 }
38728 return ((PyObject*) result);
38729 }
38730
38731 SWIGINTERN void
38732 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38733 swig_varlinkobject *v = (swig_varlinkobject *) p;
38734 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38735 if (gv) {
38736 size_t size = strlen(name)+1;
38737 gv->name = (char *)malloc(size);
38738 if (gv->name) {
38739 strncpy(gv->name,name,size);
38740 gv->get_attr = get_attr;
38741 gv->set_attr = set_attr;
38742 gv->next = v->vars;
38743 }
38744 }
38745 v->vars = gv;
38746 }
38747
38748 SWIGINTERN PyObject *
38749 SWIG_globals() {
38750 static PyObject *_SWIG_globals = 0;
38751 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38752 return _SWIG_globals;
38753 }
38754
38755 /* -----------------------------------------------------------------------------
38756 * constants/methods manipulation
38757 * ----------------------------------------------------------------------------- */
38758
38759 /* Install Constants */
38760 SWIGINTERN void
38761 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38762 PyObject *obj = 0;
38763 size_t i;
38764 for (i = 0; constants[i].type; ++i) {
38765 switch(constants[i].type) {
38766 case SWIG_PY_POINTER:
38767 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38768 break;
38769 case SWIG_PY_BINARY:
38770 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38771 break;
38772 default:
38773 obj = 0;
38774 break;
38775 }
38776 if (obj) {
38777 PyDict_SetItemString(d, constants[i].name, obj);
38778 Py_DECREF(obj);
38779 }
38780 }
38781 }
38782
38783 /* -----------------------------------------------------------------------------*/
38784 /* Fix SwigMethods to carry the callback ptrs when needed */
38785 /* -----------------------------------------------------------------------------*/
38786
38787 SWIGINTERN void
38788 SWIG_Python_FixMethods(PyMethodDef *methods,
38789 swig_const_info *const_table,
38790 swig_type_info **types,
38791 swig_type_info **types_initial) {
38792 size_t i;
38793 for (i = 0; methods[i].ml_name; ++i) {
38794 const char *c = methods[i].ml_doc;
38795 if (c && (c = strstr(c, "swig_ptr: "))) {
38796 int j;
38797 swig_const_info *ci = 0;
38798 const char *name = c + 10;
38799 for (j = 0; const_table[j].type; ++j) {
38800 if (strncmp(const_table[j].name, name,
38801 strlen(const_table[j].name)) == 0) {
38802 ci = &(const_table[j]);
38803 break;
38804 }
38805 }
38806 if (ci) {
38807 size_t shift = (ci->ptype) - types;
38808 swig_type_info *ty = types_initial[shift];
38809 size_t ldoc = (c - methods[i].ml_doc);
38810 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38811 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38812 if (ndoc) {
38813 char *buff = ndoc;
38814 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38815 if (ptr) {
38816 strncpy(buff, methods[i].ml_doc, ldoc);
38817 buff += ldoc;
38818 strncpy(buff, "swig_ptr: ", 10);
38819 buff += 10;
38820 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38821 methods[i].ml_doc = ndoc;
38822 }
38823 }
38824 }
38825 }
38826 }
38827 }
38828
38829 #ifdef __cplusplus
38830 }
38831 #endif
38832
38833 /* -----------------------------------------------------------------------------*
38834 * Partial Init method
38835 * -----------------------------------------------------------------------------*/
38836
38837 #ifdef __cplusplus
38838 extern "C"
38839 #endif
38840 SWIGEXPORT void SWIG_init(void) {
38841 PyObject *m, *d;
38842
38843 /* Fix SwigMethods to carry the callback ptrs when needed */
38844 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38845
38846 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38847 d = PyModule_GetDict(m);
38848
38849 SWIG_InitializeModule(0);
38850 SWIG_InstallConstants(d,swig_const_table);
38851
38852
38853 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38854 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38855 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38856 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38857 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38858 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38859 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38860 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38861 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38862 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38863 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38864 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38865 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38866 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38867 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38868 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38869 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38870 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38871 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38872 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38873 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38874 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38875 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38876 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38877 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38878 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38879 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38880 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38881 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38882 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38883 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38884 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38885 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38886 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38887 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38888 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38889 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38890 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38891 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38892 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38893 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38894 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38895 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38896 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38897 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38898 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38899 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38900 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38901 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38902 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38903 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38904 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38905 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38906 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38907 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38908 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38909 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38910 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38911 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38912 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38913 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38914 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38915 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38916 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38917 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38918 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38919 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38920 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38921 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38922 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38923 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38924 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38925 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38926 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38927 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38928 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38929 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38930 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38931 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38932 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38933 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38934 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38935 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38936 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38937 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38938 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38939 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38940 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38941 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38942 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38943 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38944 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38945 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38946 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38947 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38948 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38949 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38950 SWIG_Python_SetConstant(d, "UNKNOWN_PLATFORM",SWIG_From_int(static_cast< int >(wxUNKNOWN_PLATFORM)));
38951 SWIG_Python_SetConstant(d, "CURSES",SWIG_From_int(static_cast< int >(wxCURSES)));
38952 SWIG_Python_SetConstant(d, "XVIEW_X",SWIG_From_int(static_cast< int >(wxXVIEW_X)));
38953 SWIG_Python_SetConstant(d, "MOTIF_X",SWIG_From_int(static_cast< int >(wxMOTIF_X)));
38954 SWIG_Python_SetConstant(d, "COSE_X",SWIG_From_int(static_cast< int >(wxCOSE_X)));
38955 SWIG_Python_SetConstant(d, "NEXTSTEP",SWIG_From_int(static_cast< int >(wxNEXTSTEP)));
38956 SWIG_Python_SetConstant(d, "MAC",SWIG_From_int(static_cast< int >(wxMAC)));
38957 SWIG_Python_SetConstant(d, "MAC_DARWIN",SWIG_From_int(static_cast< int >(wxMAC_DARWIN)));
38958 SWIG_Python_SetConstant(d, "BEOS",SWIG_From_int(static_cast< int >(wxBEOS)));
38959 SWIG_Python_SetConstant(d, "GTK",SWIG_From_int(static_cast< int >(wxGTK)));
38960 SWIG_Python_SetConstant(d, "GTK_WIN32",SWIG_From_int(static_cast< int >(wxGTK_WIN32)));
38961 SWIG_Python_SetConstant(d, "GTK_OS2",SWIG_From_int(static_cast< int >(wxGTK_OS2)));
38962 SWIG_Python_SetConstant(d, "GTK_BEOS",SWIG_From_int(static_cast< int >(wxGTK_BEOS)));
38963 SWIG_Python_SetConstant(d, "GEOS",SWIG_From_int(static_cast< int >(wxGEOS)));
38964 SWIG_Python_SetConstant(d, "OS2_PM",SWIG_From_int(static_cast< int >(wxOS2_PM)));
38965 SWIG_Python_SetConstant(d, "WINDOWS",SWIG_From_int(static_cast< int >(wxWINDOWS)));
38966 SWIG_Python_SetConstant(d, "MICROWINDOWS",SWIG_From_int(static_cast< int >(wxMICROWINDOWS)));
38967 SWIG_Python_SetConstant(d, "PENWINDOWS",SWIG_From_int(static_cast< int >(wxPENWINDOWS)));
38968 SWIG_Python_SetConstant(d, "WINDOWS_NT",SWIG_From_int(static_cast< int >(wxWINDOWS_NT)));
38969 SWIG_Python_SetConstant(d, "WIN32S",SWIG_From_int(static_cast< int >(wxWIN32S)));
38970 SWIG_Python_SetConstant(d, "WIN95",SWIG_From_int(static_cast< int >(wxWIN95)));
38971 SWIG_Python_SetConstant(d, "WIN386",SWIG_From_int(static_cast< int >(wxWIN386)));
38972 SWIG_Python_SetConstant(d, "WINDOWS_CE",SWIG_From_int(static_cast< int >(wxWINDOWS_CE)));
38973 SWIG_Python_SetConstant(d, "WINDOWS_POCKETPC",SWIG_From_int(static_cast< int >(wxWINDOWS_POCKETPC)));
38974 SWIG_Python_SetConstant(d, "WINDOWS_SMARTPHONE",SWIG_From_int(static_cast< int >(wxWINDOWS_SMARTPHONE)));
38975 SWIG_Python_SetConstant(d, "MGL_UNIX",SWIG_From_int(static_cast< int >(wxMGL_UNIX)));
38976 SWIG_Python_SetConstant(d, "MGL_X",SWIG_From_int(static_cast< int >(wxMGL_X)));
38977 SWIG_Python_SetConstant(d, "MGL_WIN32",SWIG_From_int(static_cast< int >(wxMGL_WIN32)));
38978 SWIG_Python_SetConstant(d, "MGL_OS2",SWIG_From_int(static_cast< int >(wxMGL_OS2)));
38979 SWIG_Python_SetConstant(d, "MGL_DOS",SWIG_From_int(static_cast< int >(wxMGL_DOS)));
38980 SWIG_Python_SetConstant(d, "WINDOWS_OS2",SWIG_From_int(static_cast< int >(wxWINDOWS_OS2)));
38981 SWIG_Python_SetConstant(d, "UNIX",SWIG_From_int(static_cast< int >(wxUNIX)));
38982 SWIG_Python_SetConstant(d, "X11",SWIG_From_int(static_cast< int >(wxX11)));
38983 SWIG_Python_SetConstant(d, "PALMOS",SWIG_From_int(static_cast< int >(wxPALMOS)));
38984 SWIG_Python_SetConstant(d, "DOS",SWIG_From_int(static_cast< int >(wxDOS)));
38985 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38986 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38987 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38988 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38989 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38990
38991 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38992
38993 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38994 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38995 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38996 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38997 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38998 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38999 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
39000 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
39001 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
39002 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
39003 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
39004 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
39005 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
39006 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
39007 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
39008 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
39009 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
39010 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
39011 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
39012 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
39013 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
39014 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
39015 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
39016 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
39017 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
39018 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
39019 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
39020 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
39021 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
39022 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
39023 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
39024 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
39025 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
39026 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
39027 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
39028 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
39029 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
39030 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
39031 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
39032 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
39033 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
39034 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
39035 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
39036 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
39037 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
39038 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
39039 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
39040 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
39041 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
39042 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
39043 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
39044 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
39045 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
39046
39047 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
39048
39049 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
39050 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
39051 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
39052 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
39053 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
39054 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
39055 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
39056 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
39057 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
39058 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
39059 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
39060 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
39061 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
39062 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
39063 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
39064 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
39065 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
39066 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
39067 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
39068 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
39069 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
39070 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
39071 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
39072 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
39073 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
39074 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
39075 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
39076 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
39077 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
39078 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
39079 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
39080 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
39081 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
39082 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
39083 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
39084 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
39085 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
39086 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
39087 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
39088 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
39089 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
39090 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
39091 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
39092 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
39093 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
39094 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
39095 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
39096 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
39097 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
39098 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
39099 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
39100 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
39101 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
39102 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
39103 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
39104 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
39105 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
39106 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
39107 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
39108 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
39109 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
39110 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
39111 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
39112 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
39113 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
39114 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
39115 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
39116 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
39117 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
39118 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
39119 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
39120 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
39121 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
39122 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39123 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39124 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39125
39126 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39127
39128 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39129 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39130 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39131 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39132 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39133 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39134 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39135 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39136 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39137 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39138 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39139 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39140 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39141 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39142 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39143 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39144 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39145 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39146 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39147 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39148 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39149 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39150 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39151 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39152 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39153 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39154 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39155 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39156 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39157 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39158 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39159 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39160 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39161 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39162 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39163 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39164 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39165 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39166 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39167 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39168 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39169 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39170 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39171 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39172 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39173 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39174 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39175 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39176 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39177 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39178 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39179 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39180 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39181 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39182 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39183 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39184 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39185 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39186 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39187 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39188 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39189 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39190 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39191 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39192 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39193 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39194 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39195 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39196 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39197 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39198 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39199 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39200 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39201 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39202 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39203 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39204 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39205 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39206 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39207 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39208 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39209 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39210 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39211 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39212 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39213 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39214 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39215 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39216 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39217 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39218 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39219 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39220 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39221 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39222 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39223 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39224 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39225 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39226 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39227 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39228 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39229 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39230 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39231 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39232 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39233 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39234 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39235 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39236 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39237 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39238 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39239 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39240 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39241 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39242 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39243 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39244 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39245 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39246 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39247 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39248 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39249 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39250 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39251 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39252 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39253 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39254 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39255 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39256 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39257 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39258 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39259 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39260 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39261 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39262 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39263 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39264 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39265 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39266 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39267 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39268 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39269 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39270 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39271 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39272 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39273 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39274 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39275 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39276 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39277 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39278 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39279 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39280 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39281 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39282 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39283 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39284 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39285 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39286 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39287 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39288 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39289 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39290 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39291 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39292 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39293 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39294 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39295 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39296 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39297 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39298 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39299 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39300 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39301 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39302 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39303 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39304 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39305 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39306 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39307 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39308 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39309 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39310 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39311 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39312 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39313 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39314 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39315 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39316 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39317 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39318 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39319 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39320 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39321 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39322 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39323 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39324 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39325 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39326 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39327 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39328
39329 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39330 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39331 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39332 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39333
39334 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39335 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39336 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39337 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39338 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39339 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39340 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39341 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39342 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39343 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39344 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39345 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39346 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39347 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39348 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39349 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39350 }
39351
wxWidgets (Impactor)