]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
New SetModified method
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_form_ops_t swig_types[1]
2464 #define SWIGTYPE_p_int swig_types[2]
2465 #define SWIGTYPE_p_unsigned_char swig_types[3]
2466 #define SWIGTYPE_p_unsigned_int swig_types[4]
2467 #define SWIGTYPE_p_unsigned_long swig_types[5]
2468 #define SWIGTYPE_p_void swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxArrayString swig_types[10]
2473 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2474 #define SWIGTYPE_p_wxBitmap swig_types[12]
2475 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2476 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2477 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2478 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2480 #define SWIGTYPE_p_wxCaret swig_types[18]
2481 #define SWIGTYPE_p_wxChar swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboard swig_types[21]
2484 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2485 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2486 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2487 #define SWIGTYPE_p_wxColour swig_types[25]
2488 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2489 #define SWIGTYPE_p_wxConfig swig_types[27]
2490 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2491 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2492 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2493 #define SWIGTYPE_p_wxControl swig_types[31]
2494 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2495 #define SWIGTYPE_p_wxCursor swig_types[33]
2496 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2497 #define SWIGTYPE_p_wxDC swig_types[35]
2498 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2499 #define SWIGTYPE_p_wxDataObject swig_types[37]
2500 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2501 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2502 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2503 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2504 #define SWIGTYPE_p_wxDateTime swig_types[42]
2505 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2506 #define SWIGTYPE_p_wxDisplay swig_types[44]
2507 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2508 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2509 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2510 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2511 #define SWIGTYPE_p_wxEvent swig_types[49]
2512 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2513 #define SWIGTYPE_p_wxFSFile swig_types[51]
2514 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2515 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2516 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2517 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2518 #define SWIGTYPE_p_wxFileType swig_types[56]
2519 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2520 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2521 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2522 #define SWIGTYPE_p_wxFont swig_types[60]
2523 #define SWIGTYPE_p_wxFrame swig_types[61]
2524 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2525 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2526 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2527 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2528 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2529 #define SWIGTYPE_p_wxIcon swig_types[67]
2530 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2532 #define SWIGTYPE_p_wxImage swig_types[70]
2533 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2534 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2535 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2536 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2537 #define SWIGTYPE_p_wxJoystick swig_types[75]
2538 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2539 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2540 #define SWIGTYPE_p_wxKillError swig_types[78]
2541 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2542 #define SWIGTYPE_p_wxLog swig_types[80]
2543 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2544 #define SWIGTYPE_p_wxLogChain swig_types[82]
2545 #define SWIGTYPE_p_wxLogGui swig_types[83]
2546 #define SWIGTYPE_p_wxLogNull swig_types[84]
2547 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2548 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2549 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2550 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2551 #define SWIGTYPE_p_wxMemorySize swig_types[89]
2552 #define SWIGTYPE_p_wxMenu swig_types[90]
2553 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2554 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2555 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2556 #define SWIGTYPE_p_wxMetafile swig_types[94]
2557 #define SWIGTYPE_p_wxMetafileDataObject swig_types[95]
2558 #define SWIGTYPE_p_wxMimeTypesManager swig_types[96]
2559 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[97]
2560 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2561 #define SWIGTYPE_p_wxMouseState swig_types[99]
2562 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2563 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2564 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2565 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2566 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2567 #define SWIGTYPE_p_wxObject swig_types[105]
2568 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2569 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2572 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2573 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2574 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2575 #define SWIGTYPE_p_wxPoint swig_types[113]
2576 #define SWIGTYPE_p_wxPowerEvent swig_types[114]
2577 #define SWIGTYPE_p_wxProcessEvent swig_types[115]
2578 #define SWIGTYPE_p_wxPyApp swig_types[116]
2579 #define SWIGTYPE_p_wxPyArtProvider swig_types[117]
2580 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[118]
2581 #define SWIGTYPE_p_wxPyCommandEvent swig_types[119]
2582 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[120]
2583 #define SWIGTYPE_p_wxPyDropSource swig_types[121]
2584 #define SWIGTYPE_p_wxPyDropTarget swig_types[122]
2585 #define SWIGTYPE_p_wxPyEvent swig_types[123]
2586 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[124]
2587 #define SWIGTYPE_p_wxPyImageHandler swig_types[125]
2588 #define SWIGTYPE_p_wxPyLog swig_types[126]
2589 #define SWIGTYPE_p_wxPyProcess swig_types[127]
2590 #define SWIGTYPE_p_wxPySizer swig_types[128]
2591 #define SWIGTYPE_p_wxPyTextDataObject swig_types[129]
2592 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[130]
2593 #define SWIGTYPE_p_wxPyTimer swig_types[131]
2594 #define SWIGTYPE_p_wxPyTipProvider swig_types[132]
2595 #define SWIGTYPE_p_wxPyValidator swig_types[133]
2596 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[134]
2597 #define SWIGTYPE_p_wxRect swig_types[135]
2598 #define SWIGTYPE_p_wxScrollEvent swig_types[136]
2599 #define SWIGTYPE_p_wxScrollWinEvent swig_types[137]
2600 #define SWIGTYPE_p_wxSetCursorEvent swig_types[138]
2601 #define SWIGTYPE_p_wxShowEvent swig_types[139]
2602 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[140]
2603 #define SWIGTYPE_p_wxSize swig_types[141]
2604 #define SWIGTYPE_p_wxSizeEvent swig_types[142]
2605 #define SWIGTYPE_p_wxSizer swig_types[143]
2606 #define SWIGTYPE_p_wxSizerItem swig_types[144]
2607 #define SWIGTYPE_p_wxSound swig_types[145]
2608 #define SWIGTYPE_p_wxStandardPaths swig_types[146]
2609 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[147]
2610 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[148]
2611 #define SWIGTYPE_p_wxStopWatch swig_types[149]
2612 #define SWIGTYPE_p_wxString swig_types[150]
2613 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[151]
2614 #define SWIGTYPE_p_wxSystemOptions swig_types[152]
2615 #define SWIGTYPE_p_wxSystemSettings swig_types[153]
2616 #define SWIGTYPE_p_wxTIFFHandler swig_types[154]
2617 #define SWIGTYPE_p_wxTextCtrl swig_types[155]
2618 #define SWIGTYPE_p_wxTextDataObject swig_types[156]
2619 #define SWIGTYPE_p_wxTimeSpan swig_types[157]
2620 #define SWIGTYPE_p_wxTimer swig_types[158]
2621 #define SWIGTYPE_p_wxTimerEvent swig_types[159]
2622 #define SWIGTYPE_p_wxTimerRunner swig_types[160]
2623 #define SWIGTYPE_p_wxTipProvider swig_types[161]
2624 #define SWIGTYPE_p_wxToolTip swig_types[162]
2625 #define SWIGTYPE_p_wxURLDataObject swig_types[163]
2626 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[164]
2627 #define SWIGTYPE_p_wxValidator swig_types[165]
2628 #define SWIGTYPE_p_wxVideoMode swig_types[166]
2629 #define SWIGTYPE_p_wxWindow swig_types[167]
2630 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[168]
2631 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[169]
2632 #define SWIGTYPE_p_wxWindowDisabler swig_types[170]
2633 #define SWIGTYPE_p_wxXPMHandler swig_types[171]
2634 static swig_type_info *swig_types[173];
2635 static swig_module_info swig_module = {swig_types, 172, 0, 0, 0, 0};
2636 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2637 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2638
2639 /* -------- TYPES TABLE (END) -------- */
2640
2641 #if (PY_VERSION_HEX <= 0x02000000)
2642 # if !defined(SWIG_PYTHON_CLASSIC)
2643 # error "This python version requires to use swig with the '-classic' option"
2644 # endif
2645 #endif
2646 #if (PY_VERSION_HEX <= 0x02020000)
2647 # error "This python version requires to use swig with the '-nomodern' option"
2648 #endif
2649 #if (PY_VERSION_HEX <= 0x02020000)
2650 # error "This python version requires to use swig with the '-nomodernargs' option"
2651 #endif
2652 #ifndef METH_O
2653 # error "This python version requires to use swig with the '-nofastunpack' option"
2654 #endif
2655
2656 /*-----------------------------------------------
2657 @(target):= _misc_.so
2658 ------------------------------------------------*/
2659 #define SWIG_init init_misc_
2660
2661 #define SWIG_name "_misc_"
2662
2663 #define SWIGVERSION 0x010329
2664
2665
2666 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2667 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2668
2669
2670 #include <stdexcept>
2671
2672
2673 namespace swig {
2674 class PyObject_ptr {
2675 protected:
2676 PyObject *_obj;
2677
2678 public:
2679 PyObject_ptr() :_obj(0)
2680 {
2681 }
2682
2683 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2684 {
2685 Py_XINCREF(_obj);
2686 }
2687
2688 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2689 {
2690 if (initial_ref) Py_XINCREF(_obj);
2691 }
2692
2693 PyObject_ptr & operator=(const PyObject_ptr& item)
2694 {
2695 Py_XINCREF(item._obj);
2696 Py_XDECREF(_obj);
2697 _obj = item._obj;
2698 return *this;
2699 }
2700
2701 ~PyObject_ptr()
2702 {
2703 Py_XDECREF(_obj);
2704 }
2705
2706 operator PyObject *() const
2707 {
2708 return _obj;
2709 }
2710
2711 PyObject *operator->() const
2712 {
2713 return _obj;
2714 }
2715 };
2716 }
2717
2718
2719 namespace swig {
2720 struct PyObject_var : PyObject_ptr {
2721 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2722
2723 PyObject_var & operator = (PyObject* obj)
2724 {
2725 Py_XDECREF(_obj);
2726 _obj = obj;
2727 return *this;
2728 }
2729 };
2730 }
2731
2732
2733 #include "wx/wxPython/wxPython.h"
2734 #include "wx/wxPython/pyclasses.h"
2735 #include "wx/wxPython/pyistream.h"
2736
2737 static const wxString wxPyEmptyString(wxEmptyString);
2738
2739
2740
2741 #define SWIG_From_long PyInt_FromLong
2742
2743
2744 SWIGINTERNINLINE PyObject *
2745 SWIG_From_int (int value)
2746 {
2747 return SWIG_From_long (value);
2748 }
2749
2750
2751 #include <limits.h>
2752 #ifndef LLONG_MIN
2753 # define LLONG_MIN LONG_LONG_MIN
2754 #endif
2755 #ifndef LLONG_MAX
2756 # define LLONG_MAX LONG_LONG_MAX
2757 #endif
2758 #ifndef ULLONG_MAX
2759 # define ULLONG_MAX ULONG_LONG_MAX
2760 #endif
2761
2762
2763 SWIGINTERN int
2764 SWIG_AsVal_long (PyObject* obj, long* val)
2765 {
2766 if (PyNumber_Check(obj)) {
2767 if (val) *val = PyInt_AsLong(obj);
2768 return SWIG_OK;
2769 }
2770 return SWIG_TypeError;
2771 }
2772
2773
2774 SWIGINTERN int
2775 SWIG_AsVal_int (PyObject * obj, int *val)
2776 {
2777 long v;
2778 int res = SWIG_AsVal_long (obj, &v);
2779 if (SWIG_IsOK(res)) {
2780 if ((v < INT_MIN || v > INT_MAX)) {
2781 return SWIG_OverflowError;
2782 } else {
2783 if (val) *val = static_cast< int >(v);
2784 }
2785 }
2786 return res;
2787 }
2788
2789 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2790
2791 #include <wx/stockitem.h>
2792
2793 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2794 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2795 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2796
2797 SWIGINTERN int
2798 SWIG_AsVal_bool (PyObject *obj, bool *val)
2799 {
2800 if (obj == Py_True) {
2801 if (val) *val = true;
2802 return SWIG_OK;
2803 } else if (obj == Py_False) {
2804 if (val) *val = false;
2805 return SWIG_OK;
2806 } else {
2807 long v = 0;
2808 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2809 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2810 return res;
2811 }
2812 }
2813
2814
2815 SWIGINTERN int
2816 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2817 {
2818 long v = 0;
2819 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2820 return SWIG_TypeError;
2821 }
2822 else if (val)
2823 *val = (unsigned long)v;
2824 return SWIG_OK;
2825 }
2826
2827
2828 SWIGINTERNINLINE PyObject*
2829 SWIG_From_unsigned_SS_long (unsigned long value)
2830 {
2831 return (value > LONG_MAX) ?
2832 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2833 }
2834
2835
2836 void* wxGetXDisplay()
2837 {
2838 #ifdef __WXGTK__
2839 return wxGetDisplay();
2840 #else
2841 return NULL;
2842 #endif
2843 }
2844
2845
2846 wxWindow* FindWindowAtPointer() {
2847 wxPoint unused;
2848 return wxFindWindowAtPointer(unused);
2849 }
2850
2851
2852 bool wxThread_IsMain() {
2853 #ifdef WXP_WITH_THREAD
2854 return wxThread::IsMain();
2855 #else
2856 return true;
2857 #endif
2858 }
2859
2860 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2861 delete self;
2862 }
2863
2864 #include <wx/snglinst.h>
2865
2866
2867 #ifdef __WXMSW__
2868 #include <wx/msw/private.h>
2869 #include <wx/dynload.h>
2870 #endif
2871
2872
2873
2874 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2875 #if 0
2876 , int method
2877 #endif
2878 )
2879 {
2880 #ifdef __WXMSW__
2881 #if 0
2882 switch (method)
2883 {
2884 case 1:
2885 // This one only partially works. Appears to be an undocumented
2886 // "standard" convention that not all widgets adhear to. For
2887 // example, for some widgets backgrounds or non-client areas may
2888 // not be painted.
2889 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2890 break;
2891
2892 case 2:
2893 #endif
2894 // This one works much better, nearly all widgets and their
2895 // children are captured correctly[**]. Prior to the big
2896 // background erase changes that Vadim did in 2004-2005 this
2897 // method failed badly on XP with Themes activated, most native
2898 // widgets draw only partially, if at all. Without themes it
2899 // worked just like on Win2k. After those changes this method
2900 // works very well.
2901 //
2902 // ** For example the radio buttons in a wxRadioBox are not its
2903 // children by default, but you can capture it via the panel
2904 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2905 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2906 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2907 PRF_ERASEBKGND | PRF_OWNED );
2908 return true;
2909 #if 0
2910 break;
2911
2912 case 3:
2913 // This one is only defined in the latest SDK and is only
2914 // available on XP. MSDN says it is similar to sending WM_PRINT
2915 // so I expect that it will work similar to the above. Since it
2916 // is avaialble only on XP, it can't be compiled like this and
2917 // will have to be loaded dynamically.
2918 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2919
2920 // fall through
2921
2922 case 4:
2923 // Use PrintWindow if available, or fallback to WM_PRINT
2924 // otherwise. Unfortunately using PrintWindow is even worse than
2925 // WM_PRINT. For most native widgets nothing is drawn to the dc
2926 // at all, with or without Themes.
2927 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2928 static bool s_triedToLoad = false;
2929 static PrintWindow_t pfnPrintWindow = NULL;
2930 if ( !s_triedToLoad )
2931 {
2932
2933 s_triedToLoad = true;
2934 wxDynamicLibrary dllUser32(_T("user32.dll"));
2935 if ( dllUser32.IsLoaded() )
2936 {
2937 wxLogNull nolog; // Don't report errors here
2938 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2939 }
2940 }
2941 if (pfnPrintWindow)
2942 {
2943 //printf("Using PrintWindow\n");
2944 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2945 }
2946 else
2947 {
2948 //printf("Using WM_PRINT\n");
2949 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2950 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2951 PRF_ERASEBKGND | PRF_OWNED );
2952 }
2953 }
2954 #endif // 0
2955 #else
2956 return false;
2957 #endif // __WXMSW__
2958 }
2959
2960
2961
2962 #include <wx/tipdlg.h>
2963
2964
2965 SWIGINTERNINLINE PyObject *
2966 SWIG_From_size_t (size_t value)
2967 {
2968 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2969 }
2970
2971
2972 class wxPyTipProvider : public wxTipProvider {
2973 public:
2974 wxPyTipProvider(size_t currentTip)
2975 : wxTipProvider(currentTip) {}
2976
2977 DEC_PYCALLBACK_STRING__pure(GetTip);
2978 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2979 PYPRIVATE;
2980 };
2981
2982 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2983 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2984
2985
2986 SWIGINTERNINLINE int
2987 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2988 {
2989 unsigned long v;
2990 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2991 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2992 return res;
2993 }
2994
2995
2996 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
2997
2998 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
2999
3000 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3001 : wxTimer(owner, id)
3002 {
3003 if (owner == NULL)
3004 SetOwner(this);
3005 }
3006
3007
3008 SWIGINTERN swig_type_info*
3009 SWIG_pchar_descriptor()
3010 {
3011 static int init = 0;
3012 static swig_type_info* info = 0;
3013 if (!init) {
3014 info = SWIG_TypeQuery("_p_char");
3015 init = 1;
3016 }
3017 return info;
3018 }
3019
3020
3021 SWIGINTERNINLINE PyObject *
3022 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3023 {
3024 if (carray) {
3025 if (size > INT_MAX) {
3026 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3027 return pchar_descriptor ?
3028 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3029 } else {
3030 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3031 }
3032 } else {
3033 return SWIG_Py_Void();
3034 }
3035 }
3036
3037
3038 SWIGINTERNINLINE PyObject *
3039 SWIG_FromCharPtr(const char *cptr)
3040 {
3041 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3042 }
3043
3044
3045 SWIGINTERN int
3046 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3047 {
3048 unsigned long v;
3049 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3050 if (SWIG_IsOK(res)) {
3051 if ((v > UINT_MAX)) {
3052 return SWIG_OverflowError;
3053 } else {
3054 if (val) *val = static_cast< unsigned int >(v);
3055 }
3056 }
3057 return res;
3058 }
3059
3060 SWIGINTERN wxString wxLog_TimeStamp(){
3061 wxString msg;
3062 wxLog::TimeStamp(&msg);
3063 return msg;
3064 }
3065 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3066 // Make some wrappers that double any % signs so they are 'escaped'
3067 void wxPyLogFatalError(const wxString& msg)
3068 {
3069 wxString m(msg);
3070 m.Replace(wxT("%"), wxT("%%"));
3071 wxLogFatalError(m);
3072 }
3073
3074 void wxPyLogError(const wxString& msg)
3075 {
3076 wxString m(msg);
3077 m.Replace(wxT("%"), wxT("%%"));
3078 wxLogError(m);
3079 }
3080
3081 void wxPyLogWarning(const wxString& msg)
3082 {
3083 wxString m(msg);
3084 m.Replace(wxT("%"), wxT("%%"));
3085 wxLogWarning(m);
3086 }
3087
3088 void wxPyLogMessage(const wxString& msg)
3089 {
3090 wxString m(msg);
3091 m.Replace(wxT("%"), wxT("%%"));
3092 wxLogMessage(m);
3093 }
3094
3095 void wxPyLogInfo(const wxString& msg)
3096 {
3097 wxString m(msg);
3098 m.Replace(wxT("%"), wxT("%%"));
3099 wxLogInfo(m);
3100 }
3101
3102 void wxPyLogDebug(const wxString& msg)
3103 {
3104 wxString m(msg);
3105 m.Replace(wxT("%"), wxT("%%"));
3106 wxLogDebug(m);
3107 }
3108
3109 void wxPyLogVerbose(const wxString& msg)
3110 {
3111 wxString m(msg);
3112 m.Replace(wxT("%"), wxT("%%"));
3113 wxLogVerbose(m);
3114 }
3115
3116 void wxPyLogStatus(const wxString& msg)
3117 {
3118 wxString m(msg);
3119 m.Replace(wxT("%"), wxT("%%"));
3120 wxLogStatus(m);
3121 }
3122
3123 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3124 {
3125 wxString m(msg);
3126 m.Replace(wxT("%"), wxT("%%"));
3127 wxLogStatus(pFrame, m);
3128 }
3129
3130 void wxPyLogSysError(const wxString& msg)
3131 {
3132 wxString m(msg);
3133 m.Replace(wxT("%"), wxT("%%"));
3134 wxLogSysError(m);
3135 }
3136
3137 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3138 {
3139 wxString m(msg);
3140 m.Replace(wxT("%"), wxT("%%"));
3141 wxLogGeneric(level, m);
3142 }
3143
3144 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3145 {
3146 wxString m(msg);
3147 m.Replace(wxT("%"), wxT("%%"));
3148 wxLogTrace(mask, m);
3149 }
3150
3151 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3152 {
3153 wxString m(msg);
3154 m.Replace(wxT("%"), wxT("%%"));
3155 wxLogTrace(mask, m);
3156 }
3157
3158
3159
3160 // A wxLog class that can be derived from in wxPython
3161 class wxPyLog : public wxLog {
3162 public:
3163 wxPyLog() : wxLog() {}
3164
3165 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3166 bool found;
3167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3168 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3169 PyObject* s = wx2PyString(szString);
3170 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3171 Py_DECREF(s);
3172 }
3173 wxPyEndBlockThreads(blocked);
3174 if (! found)
3175 wxLog::DoLog(level, szString, t);
3176 }
3177
3178 virtual void DoLogString(const wxChar *szString, time_t t) {
3179 bool found;
3180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3181 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3182 PyObject* s = wx2PyString(szString);
3183 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3184 Py_DECREF(s);
3185 }
3186 wxPyEndBlockThreads(blocked);
3187 if (! found)
3188 wxLog::DoLogString(szString, t);
3189 }
3190
3191 DEC_PYCALLBACK_VOID_(Flush);
3192 PYPRIVATE;
3193 };
3194 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3195
3196
3197
3198
3199 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3200
3201
3202 #include <wx/joystick.h>
3203
3204
3205 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3206 // A C++ stub class for wxJoystick for platforms that don't have it.
3207 class wxJoystick : public wxObject {
3208 public:
3209 wxJoystick(int joystick = wxJOYSTICK1) {
3210 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3211 PyErr_SetString(PyExc_NotImplementedError,
3212 "wxJoystick is not available on this platform.");
3213 wxPyEndBlockThreads(blocked);
3214 }
3215 wxPoint GetPosition() { return wxPoint(-1,-1); }
3216 int GetZPosition() { return -1; }
3217 int GetButtonState() { return -1; }
3218 int GetPOVPosition() { return -1; }
3219 int GetPOVCTSPosition() { return -1; }
3220 int GetRudderPosition() { return -1; }
3221 int GetUPosition() { return -1; }
3222 int GetVPosition() { return -1; }
3223 int GetMovementThreshold() { return -1; }
3224 void SetMovementThreshold(int threshold) {}
3225
3226 bool IsOk(void) { return false; }
3227 int GetNumberJoysticks() { return -1; }
3228 int GetManufacturerId() { return -1; }
3229 int GetProductId() { return -1; }
3230 wxString GetProductName() { return wxEmptyString; }
3231 int GetXMin() { return -1; }
3232 int GetYMin() { return -1; }
3233 int GetZMin() { return -1; }
3234 int GetXMax() { return -1; }
3235 int GetYMax() { return -1; }
3236 int GetZMax() { return -1; }
3237 int GetNumberButtons() { return -1; }
3238 int GetNumberAxes() { return -1; }
3239 int GetMaxButtons() { return -1; }
3240 int GetMaxAxes() { return -1; }
3241 int GetPollingMin() { return -1; }
3242 int GetPollingMax() { return -1; }
3243 int GetRudderMin() { return -1; }
3244 int GetRudderMax() { return -1; }
3245 int GetUMin() { return -1; }
3246 int GetUMax() { return -1; }
3247 int GetVMin() { return -1; }
3248 int GetVMax() { return -1; }
3249
3250 bool HasRudder() { return false; }
3251 bool HasZ() { return false; }
3252 bool HasU() { return false; }
3253 bool HasV() { return false; }
3254 bool HasPOV() { return false; }
3255 bool HasPOV4Dir() { return false; }
3256 bool HasPOVCTS() { return false; }
3257
3258 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3259 bool ReleaseCapture() { return false; }
3260 };
3261 #endif
3262
3263
3264 #include <wx/sound.h>
3265
3266
3267 #if !wxUSE_SOUND
3268 // A C++ stub class for wxWave for platforms that don't have it.
3269 class wxSound : public wxObject
3270 {
3271 public:
3272 wxSound() {
3273 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3274 PyErr_SetString(PyExc_NotImplementedError,
3275 "wxSound is not available on this platform.");
3276 wxPyEndBlockThreads(blocked);
3277 }
3278 wxSound(const wxString&/*, bool*/) {
3279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3280 PyErr_SetString(PyExc_NotImplementedError,
3281 "wxSound is not available on this platform.");
3282 wxPyEndBlockThreads(blocked);
3283 }
3284 wxSound(int, const wxByte*) {
3285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3286 PyErr_SetString(PyExc_NotImplementedError,
3287 "wxSound is not available on this platform.");
3288 wxPyEndBlockThreads(blocked);
3289 }
3290
3291 ~wxSound() {};
3292
3293 bool Create(const wxString&/*, bool*/) { return false; }
3294 bool Create(int, const wxByte*) { return false; };
3295 bool IsOk() { return false; };
3296 bool Play(unsigned) const { return false; }
3297 static bool Play(const wxString&, unsigned) { return false; }
3298 static void Stop() {}
3299 };
3300
3301 #endif
3302
3303 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3304 if (fileName.Length() == 0)
3305 return new wxSound;
3306 else
3307 return new wxSound(fileName);
3308 }
3309 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3310 unsigned char* buffer; int size;
3311 wxSound *sound = NULL;
3312
3313 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3314 if (!PyArg_Parse(data, "t#", &buffer, &size))
3315 goto done;
3316 sound = new wxSound(size, buffer);
3317 done:
3318 wxPyEndBlockThreads(blocked);
3319 return sound;
3320 }
3321 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3322 #ifndef __WXMAC__
3323 unsigned char* buffer;
3324 int size;
3325 bool rv = false;
3326
3327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3328 if (!PyArg_Parse(data, "t#", &buffer, &size))
3329 goto done;
3330 rv = self->Create(size, buffer);
3331 done:
3332 wxPyEndBlockThreads(blocked);
3333 return rv;
3334 #else
3335 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3336 PyErr_SetString(PyExc_NotImplementedError,
3337 "Create from data is not available on this platform.");
3338 wxPyEndBlockThreads(blocked);
3339 return false;
3340 #endif
3341 }
3342
3343 #include <wx/mimetype.h>
3344
3345 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3346 wxString str;
3347 if (self->GetMimeType(&str))
3348 return wx2PyString(str);
3349 else
3350 RETURN_NONE();
3351 }
3352 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3353 wxArrayString arr;
3354 if (self->GetMimeTypes(arr))
3355 return wxArrayString2PyList_helper(arr);
3356 else
3357 RETURN_NONE();
3358 }
3359 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3360 wxArrayString arr;
3361 if (self->GetExtensions(arr))
3362 return wxArrayString2PyList_helper(arr);
3363 else
3364 RETURN_NONE();
3365 }
3366 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3367 wxIconLocation loc;
3368 if (self->GetIcon(&loc))
3369 return new wxIcon(loc);
3370 else
3371 return NULL;
3372 }
3373 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3374 wxIconLocation loc;
3375 if (self->GetIcon(&loc)) {
3376 wxString iconFile = loc.GetFileName();
3377 int iconIndex = -1;
3378
3379
3380
3381 // Make a tuple and put the values in it
3382 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3383 PyObject* tuple = PyTuple_New(3);
3384 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3385 wxT("wxIcon"), true));
3386 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3387 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3388 wxPyEndBlockThreads(blocked);
3389 return tuple;
3390 }
3391 else
3392 RETURN_NONE();
3393 }
3394 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3395 wxString str;
3396 if (self->GetDescription(&str))
3397 return wx2PyString(str);
3398 else
3399 RETURN_NONE();
3400 }
3401 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3402 wxString str;
3403 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3404 return wx2PyString(str);
3405 else
3406 RETURN_NONE();
3407 }
3408 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3409 wxString str;
3410 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3411 return wx2PyString(str);
3412 else
3413 RETURN_NONE();
3414 }
3415 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3416 wxArrayString verbs;
3417 wxArrayString commands;
3418 if (self->GetAllCommands(&verbs, &commands,
3419 wxFileType::MessageParameters(filename, mimetype))) {
3420 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3421 PyObject* tuple = PyTuple_New(2);
3422 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3423 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3424 wxPyEndBlockThreads(blocked);
3425 return tuple;
3426 }
3427 else
3428 RETURN_NONE();
3429 }
3430 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3431 return wxFileType::ExpandCommand(command,
3432 wxFileType::MessageParameters(filename, mimetype));
3433 }
3434 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3435 wxArrayString arr;
3436 self->EnumAllFileTypes(arr);
3437 return wxArrayString2PyList_helper(arr);
3438 }
3439
3440 #include <wx/artprov.h>
3441
3442 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3443 static const wxString wxPyART_MENU(wxART_MENU);
3444 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3445 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3446 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3447 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3448 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3449 static const wxString wxPyART_OTHER(wxART_OTHER);
3450 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3451 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3452 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3453 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3454 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3455 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3456 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3457 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3458 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3459 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3460 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3461 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3462 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3463 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3464 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3465 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3466 static const wxString wxPyART_PRINT(wxART_PRINT);
3467 static const wxString wxPyART_HELP(wxART_HELP);
3468 static const wxString wxPyART_TIP(wxART_TIP);
3469 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3470 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3471 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3472 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3473 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3474 static const wxString wxPyART_CDROM(wxART_CDROM);
3475 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3476 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3477 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3478 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3479 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3480 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3481 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3482 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3483 static const wxString wxPyART_ERROR(wxART_ERROR);
3484 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3485 static const wxString wxPyART_WARNING(wxART_WARNING);
3486 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3487 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3488 static const wxString wxPyART_COPY(wxART_COPY);
3489 static const wxString wxPyART_CUT(wxART_CUT);
3490 static const wxString wxPyART_PASTE(wxART_PASTE);
3491 static const wxString wxPyART_DELETE(wxART_DELETE);
3492 static const wxString wxPyART_NEW(wxART_NEW);
3493 static const wxString wxPyART_UNDO(wxART_UNDO);
3494 static const wxString wxPyART_REDO(wxART_REDO);
3495 static const wxString wxPyART_QUIT(wxART_QUIT);
3496 static const wxString wxPyART_FIND(wxART_FIND);
3497 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3498 // Python aware wxArtProvider
3499 class wxPyArtProvider : public wxArtProvider {
3500 public:
3501
3502 virtual wxBitmap CreateBitmap(const wxArtID& id,
3503 const wxArtClient& client,
3504 const wxSize& size) {
3505 wxBitmap rval = wxNullBitmap;
3506 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3507 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3508 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3509 PyObject* ro;
3510 wxBitmap* ptr;
3511 PyObject* s1, *s2;
3512 s1 = wx2PyString(id);
3513 s2 = wx2PyString(client);
3514 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3515 Py_DECREF(so);
3516 Py_DECREF(s1);
3517 Py_DECREF(s2);
3518 if (ro) {
3519 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3520 rval = *ptr;
3521 Py_DECREF(ro);
3522 }
3523 }
3524 wxPyEndBlockThreads(blocked);
3525 return rval;
3526 }
3527
3528 PYPRIVATE;
3529 };
3530
3531 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3532
3533
3534
3535 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3536 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3537 PyObject* ret = PyTuple_New(3);
3538 if (ret) {
3539 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3540 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3541 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3542 }
3543 wxPyEndBlockThreads(blocked);
3544 return ret;
3545 }
3546
3547 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3548 bool cont;
3549 long index = 0;
3550 wxString value;
3551
3552 cont = self->GetFirstGroup(value, index);
3553 return __EnumerationHelper(cont, value, index);
3554 }
3555 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3556 bool cont;
3557 wxString value;
3558
3559 cont = self->GetNextGroup(value, index);
3560 return __EnumerationHelper(cont, value, index);
3561 }
3562 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3563 bool cont;
3564 long index = 0;
3565 wxString value;
3566
3567 cont = self->GetFirstEntry(value, index);
3568 return __EnumerationHelper(cont, value, index);
3569 }
3570 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3571 bool cont;
3572 wxString value;
3573
3574 cont = self->GetNextEntry(value, index);
3575 return __EnumerationHelper(cont, value, index);
3576 }
3577 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3578 long rv;
3579 self->Read(key, &rv, defaultVal);
3580 return rv;
3581 }
3582
3583 SWIGINTERN int
3584 SWIG_AsVal_double (PyObject *obj, double* val)
3585 {
3586 if (PyNumber_Check(obj)) {
3587 if (val) *val = PyFloat_AsDouble(obj);
3588 return SWIG_OK;
3589 }
3590 return SWIG_TypeError;
3591 }
3592
3593 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3594 double rv;
3595 self->Read(key, &rv, defaultVal);
3596 return rv;
3597 }
3598
3599 #define SWIG_From_double PyFloat_FromDouble
3600
3601 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3602 bool rv;
3603 self->Read(key, &rv, defaultVal);
3604 return rv;
3605 }
3606
3607 #include <wx/datetime.h>
3608
3609 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3610 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3611
3612 #define LOCAL_TZ wxDateTime::Local
3613
3614 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3615 wxString am;
3616 wxString pm;
3617 wxDateTime::GetAmPmStrings(&am, &pm);
3618 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3619 PyObject* tup = PyTuple_New(2);
3620 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3621 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3622 wxPyEndBlockThreads(blocked);
3623 return tup;
3624 }
3625
3626 SWIGINTERNINLINE PyObject *
3627 SWIG_From_unsigned_SS_int (unsigned int value)
3628 {
3629 return SWIG_From_unsigned_SS_long (value);
3630 }
3631
3632 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3633 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3634 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3635 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3636 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3637 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3638 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3639 return (*self < *other);
3640 }
3641 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3642 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3643 return (*self <= *other);
3644 }
3645 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3646 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3647 return (*self > *other);
3648 }
3649 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3650 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3651 return (*self >= *other);
3652 }
3653 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3654 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3655 return (*self == *other);
3656 }
3657 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3658 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3659 return (*self != *other);
3660 }
3661 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3662 const wxChar* rv;
3663 const wxChar* _date = date;
3664 rv = self->ParseRfc822Date(_date);
3665 if (rv == NULL) return -1;
3666 return rv - _date;
3667 }
3668 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3669 const wxChar* rv;
3670 const wxChar* _date = date;
3671 rv = self->ParseFormat(_date, format, dateDef);
3672 if (rv == NULL) return -1;
3673 return rv - _date;
3674 }
3675 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3676 const wxChar* rv;
3677 const wxChar* _datetime = datetime;
3678 rv = self->ParseDateTime(_datetime);
3679 if (rv == NULL) return -1;
3680 return rv - _datetime;
3681 }
3682 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3683 const wxChar* rv;
3684 const wxChar* _date = date;
3685 rv = self->ParseDate(_date);
3686 if (rv == NULL) return -1;
3687 return rv - _date;
3688 }
3689 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3690 const wxChar* rv;
3691 const wxChar* _time = time;
3692 rv = self->ParseTime(_time);
3693 if (rv == NULL) return -1;
3694 return rv - _time;
3695 }
3696 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3697 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3698 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3699 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3700 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3701 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3702 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3703 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3704 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3705 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3706 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3707 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3708 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3709 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3710 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3711 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3712
3713 #include <wx/dataobj.h>
3714
3715 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3716 size_t count = self->GetFormatCount(dir);
3717 wxDataFormat* formats = new wxDataFormat[count];
3718 self->GetAllFormats(formats, dir);
3719
3720 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3721 PyObject* list = PyList_New(count);
3722 for (size_t i=0; i<count; i++) {
3723 wxDataFormat* format = new wxDataFormat(formats[i]);
3724 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3725 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3726 }
3727 wxPyEndBlockThreads(blocked);
3728 delete [] formats;
3729 return list;
3730 }
3731 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3732 PyObject* rval = NULL;
3733 size_t size = self->GetDataSize(format);
3734 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3735 if (size) {
3736 char* buf = new char[size];
3737 if (self->GetDataHere(format, buf))
3738 rval = PyString_FromStringAndSize(buf, size);
3739 delete [] buf;
3740 }
3741 if (! rval) {
3742 rval = Py_None;
3743 Py_INCREF(rval);
3744 }
3745 wxPyEndBlockThreads(blocked);
3746 return rval;
3747 }
3748 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3749 bool rval;
3750 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3751 if (PyString_Check(data)) {
3752 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3753 }
3754 else {
3755 // raise a TypeError if not a string
3756 PyErr_SetString(PyExc_TypeError, "String expected.");
3757 rval = false;
3758 }
3759 wxPyEndBlockThreads(blocked);
3760 return rval;
3761 }
3762 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3763 PyObject* rval = NULL;
3764 size_t size = self->GetDataSize();
3765 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3766 if (size) {
3767 char* buf = new char[size];
3768 if (self->GetDataHere(buf))
3769 rval = PyString_FromStringAndSize(buf, size);
3770 delete [] buf;
3771 }
3772 if (! rval) {
3773 rval = Py_None;
3774 Py_INCREF(rval);
3775 }
3776 wxPyEndBlockThreads(blocked);
3777 return rval;
3778 }
3779 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3780 bool rval;
3781 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3782 if (PyString_Check(data)) {
3783 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3784 }
3785 else {
3786 // raise a TypeError if not a string
3787 PyErr_SetString(PyExc_TypeError, "String expected.");
3788 rval = false;
3789 }
3790 wxPyEndBlockThreads(blocked);
3791 return rval;
3792 }
3793 // Create a new class for wxPython to use
3794 class wxPyDataObjectSimple : public wxDataObjectSimple {
3795 public:
3796 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3797 : wxDataObjectSimple(format) {}
3798
3799 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3800 bool GetDataHere(void *buf) const;
3801 bool SetData(size_t len, const void *buf) const;
3802 PYPRIVATE;
3803 };
3804
3805 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3806
3807 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3808 // We need to get the data for this object and write it to buf. I think
3809 // the best way to do this for wxPython is to have the Python method
3810 // return either a string or None and then act appropriately with the
3811 // C++ version.
3812
3813 bool rval = false;
3814 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3815 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3816 PyObject* ro;
3817 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3818 if (ro) {
3819 rval = (ro != Py_None && PyString_Check(ro));
3820 if (rval)
3821 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3822 Py_DECREF(ro);
3823 }
3824 }
3825 wxPyEndBlockThreads(blocked);
3826 return rval;
3827 }
3828
3829 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3830 // For this one we simply need to make a string from buf and len
3831 // and send it to the Python method.
3832 bool rval = false;
3833 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3834 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3835 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3836 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3837 Py_DECREF(data);
3838 }
3839 wxPyEndBlockThreads(blocked);
3840 return rval;
3841 }
3842
3843 // Create a new class for wxPython to use
3844 class wxPyTextDataObject : public wxTextDataObject {
3845 public:
3846 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3847 : wxTextDataObject(text) {}
3848
3849 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3850 DEC_PYCALLBACK_STRING__const(GetText);
3851 DEC_PYCALLBACK__STRING(SetText);
3852 PYPRIVATE;
3853 };
3854
3855 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3856 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3857 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3858
3859
3860 // Create a new class for wxPython to use
3861 class wxPyBitmapDataObject : public wxBitmapDataObject {
3862 public:
3863 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3864 : wxBitmapDataObject(bitmap) {}
3865
3866 wxBitmap GetBitmap() const;
3867 void SetBitmap(const wxBitmap& bitmap);
3868 PYPRIVATE;
3869 };
3870
3871 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3872 wxBitmap* rval = &wxNullBitmap;
3873 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3874 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3875 PyObject* ro;
3876 wxBitmap* ptr;
3877 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3878 if (ro) {
3879 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3880 rval = ptr;
3881 Py_DECREF(ro);
3882 }
3883 }
3884 wxPyEndBlockThreads(blocked);
3885 return *rval;
3886 }
3887
3888 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3889 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3890 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3891 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3892 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3893 Py_DECREF(bo);
3894 }
3895 wxPyEndBlockThreads(blocked);
3896 }
3897
3898 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3899 return new wxCustomDataObject(wxDataFormat(formatName));
3900 }
3901 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3902 bool rval;
3903 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3904 if (PyString_Check(data)) {
3905 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3906 }
3907 else {
3908 // raise a TypeError if not a string
3909 PyErr_SetString(PyExc_TypeError, "String expected.");
3910 rval = false;
3911 }
3912 wxPyEndBlockThreads(blocked);
3913 return rval;
3914 }
3915 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3916 PyObject* obj;
3917 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3918 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3919 wxPyEndBlockThreads(blocked);
3920 return obj;
3921 }
3922
3923 #include <wx/metafile.h>
3924
3925
3926 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3927
3928
3929 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3930 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3931 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3932 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3933 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3934
3935
3936 class wxPyTextDropTarget : public wxTextDropTarget {
3937 public:
3938 wxPyTextDropTarget() {}
3939
3940 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3941
3942 DEC_PYCALLBACK__(OnLeave);
3943 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3944 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3945 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3946 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3947
3948 PYPRIVATE;
3949 };
3950
3951 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3952 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3953 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3954 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3955 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3956 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3957
3958
3959
3960 class wxPyFileDropTarget : public wxFileDropTarget {
3961 public:
3962 wxPyFileDropTarget() {}
3963
3964 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3965
3966 DEC_PYCALLBACK__(OnLeave);
3967 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3968 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3969 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3970 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3971
3972 PYPRIVATE;
3973 };
3974
3975 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3976 const wxArrayString& filenames) {
3977 bool rval = false;
3978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3979 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3980 PyObject* list = wxArrayString2PyList_helper(filenames);
3981 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3982 Py_DECREF(list);
3983 }
3984 wxPyEndBlockThreads(blocked);
3985 return rval;
3986 }
3987
3988
3989
3990 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3991 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3992 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3993 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3994 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3995
3996
3997
3998
3999 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4000
4001 #include <wx/display.h>
4002
4003 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4004 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4005
4006 #if !wxUSE_DISPLAY
4007 const wxVideoMode wxDefaultVideoMode;
4008 #endif
4009
4010 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4011 #if wxUSE_DISPLAY
4012 PyObject* pyList = NULL;
4013 wxArrayVideoModes arr = self->GetModes(mode);
4014 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4015 pyList = PyList_New(0);
4016 for (size_t i=0; i < arr.GetCount(); i++)
4017 {
4018 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4019 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4020 PyList_Append(pyList, pyObj);
4021 Py_DECREF(pyObj);
4022 }
4023 wxPyEndBlockThreads(blocked);
4024 return pyList;
4025 #else
4026 wxPyRaiseNotImplemented();
4027 return NULL;
4028 #endif
4029 }
4030 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4031 #if wxUSE_DISPLAY
4032 return self->GetCurrentMode();
4033 #else
4034 wxPyRaiseNotImplemented();
4035 return wxDefaultVideoMode;
4036 #endif
4037 }
4038 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4039 #if wxUSE_DISPLAY
4040 return self->ChangeMode(mode);
4041 #else
4042 wxPyRaiseNotImplemented();
4043 return false;
4044 #endif
4045 }
4046 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4047 #if wxUSE_DISPLAY
4048 self->ResetMode();
4049 #else
4050 wxPyRaiseNotImplemented();
4051 #endif
4052 }
4053
4054 #include <wx/stdpaths.h>
4055
4056 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4057 return (wxStandardPaths*) &wxStandardPaths::Get();
4058 }
4059 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4060 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4061
4062 #ifndef wxHAS_POWER_EVENTS
4063 // Dummy class and other definitions for platforms that don't have them
4064
4065 // See wxPython_int.h for wxPowerEvent
4066
4067 enum {
4068 wxEVT_POWER_SUSPENDING,
4069 wxEVT_POWER_SUSPENDED,
4070 wxEVT_POWER_SUSPEND_CANCEL,
4071 wxEVT_POWER_RESUME,
4072 };
4073
4074 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4075 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4076
4077 #endif
4078
4079 #ifdef __cplusplus
4080 extern "C" {
4081 #endif
4082 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4083 PyObject *resultobj = 0;
4084 wxSystemColour arg1 ;
4085 wxColour result;
4086 int val1 ;
4087 int ecode1 = 0 ;
4088 PyObject * obj0 = 0 ;
4089 char * kwnames[] = {
4090 (char *) "index", NULL
4091 };
4092
4093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4094 ecode1 = SWIG_AsVal_int(obj0, &val1);
4095 if (!SWIG_IsOK(ecode1)) {
4096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4097 }
4098 arg1 = static_cast< wxSystemColour >(val1);
4099 {
4100 if (!wxPyCheckForApp()) SWIG_fail;
4101 PyThreadState* __tstate = wxPyBeginAllowThreads();
4102 result = wxSystemSettings::GetColour(arg1);
4103 wxPyEndAllowThreads(__tstate);
4104 if (PyErr_Occurred()) SWIG_fail;
4105 }
4106 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4107 return resultobj;
4108 fail:
4109 return NULL;
4110 }
4111
4112
4113 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4114 PyObject *resultobj = 0;
4115 wxSystemFont arg1 ;
4116 wxFont result;
4117 int val1 ;
4118 int ecode1 = 0 ;
4119 PyObject * obj0 = 0 ;
4120 char * kwnames[] = {
4121 (char *) "index", NULL
4122 };
4123
4124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4125 ecode1 = SWIG_AsVal_int(obj0, &val1);
4126 if (!SWIG_IsOK(ecode1)) {
4127 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4128 }
4129 arg1 = static_cast< wxSystemFont >(val1);
4130 {
4131 if (!wxPyCheckForApp()) SWIG_fail;
4132 PyThreadState* __tstate = wxPyBeginAllowThreads();
4133 result = wxSystemSettings::GetFont(arg1);
4134 wxPyEndAllowThreads(__tstate);
4135 if (PyErr_Occurred()) SWIG_fail;
4136 }
4137 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4138 return resultobj;
4139 fail:
4140 return NULL;
4141 }
4142
4143
4144 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4145 PyObject *resultobj = 0;
4146 wxSystemMetric arg1 ;
4147 wxWindow *arg2 = (wxWindow *) NULL ;
4148 int result;
4149 int val1 ;
4150 int ecode1 = 0 ;
4151 void *argp2 = 0 ;
4152 int res2 = 0 ;
4153 PyObject * obj0 = 0 ;
4154 PyObject * obj1 = 0 ;
4155 char * kwnames[] = {
4156 (char *) "index",(char *) "win", NULL
4157 };
4158
4159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4160 ecode1 = SWIG_AsVal_int(obj0, &val1);
4161 if (!SWIG_IsOK(ecode1)) {
4162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4163 }
4164 arg1 = static_cast< wxSystemMetric >(val1);
4165 if (obj1) {
4166 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4167 if (!SWIG_IsOK(res2)) {
4168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4169 }
4170 arg2 = reinterpret_cast< wxWindow * >(argp2);
4171 }
4172 {
4173 if (!wxPyCheckForApp()) SWIG_fail;
4174 PyThreadState* __tstate = wxPyBeginAllowThreads();
4175 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4176 wxPyEndAllowThreads(__tstate);
4177 if (PyErr_Occurred()) SWIG_fail;
4178 }
4179 resultobj = SWIG_From_int(static_cast< int >(result));
4180 return resultobj;
4181 fail:
4182 return NULL;
4183 }
4184
4185
4186 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4187 PyObject *resultobj = 0;
4188 wxSystemFeature arg1 ;
4189 bool result;
4190 int val1 ;
4191 int ecode1 = 0 ;
4192 PyObject * obj0 = 0 ;
4193 char * kwnames[] = {
4194 (char *) "index", NULL
4195 };
4196
4197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4198 ecode1 = SWIG_AsVal_int(obj0, &val1);
4199 if (!SWIG_IsOK(ecode1)) {
4200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4201 }
4202 arg1 = static_cast< wxSystemFeature >(val1);
4203 {
4204 if (!wxPyCheckForApp()) SWIG_fail;
4205 PyThreadState* __tstate = wxPyBeginAllowThreads();
4206 result = (bool)wxSystemSettings::HasFeature(arg1);
4207 wxPyEndAllowThreads(__tstate);
4208 if (PyErr_Occurred()) SWIG_fail;
4209 }
4210 {
4211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4212 }
4213 return resultobj;
4214 fail:
4215 return NULL;
4216 }
4217
4218
4219 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4220 PyObject *resultobj = 0;
4221 wxSystemScreenType result;
4222
4223 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4224 {
4225 if (!wxPyCheckForApp()) SWIG_fail;
4226 PyThreadState* __tstate = wxPyBeginAllowThreads();
4227 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4228 wxPyEndAllowThreads(__tstate);
4229 if (PyErr_Occurred()) SWIG_fail;
4230 }
4231 resultobj = SWIG_From_int(static_cast< int >(result));
4232 return resultobj;
4233 fail:
4234 return NULL;
4235 }
4236
4237
4238 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4239 PyObject *resultobj = 0;
4240 wxSystemScreenType arg1 ;
4241 int val1 ;
4242 int ecode1 = 0 ;
4243 PyObject * obj0 = 0 ;
4244 char * kwnames[] = {
4245 (char *) "screen", NULL
4246 };
4247
4248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4249 ecode1 = SWIG_AsVal_int(obj0, &val1);
4250 if (!SWIG_IsOK(ecode1)) {
4251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4252 }
4253 arg1 = static_cast< wxSystemScreenType >(val1);
4254 {
4255 if (!wxPyCheckForApp()) SWIG_fail;
4256 PyThreadState* __tstate = wxPyBeginAllowThreads();
4257 wxSystemSettings::SetScreenType(arg1);
4258 wxPyEndAllowThreads(__tstate);
4259 if (PyErr_Occurred()) SWIG_fail;
4260 }
4261 resultobj = SWIG_Py_Void();
4262 return resultobj;
4263 fail:
4264 return NULL;
4265 }
4266
4267
4268 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4269 PyObject *obj;
4270 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4271 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4272 return SWIG_Py_Void();
4273 }
4274
4275 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4276 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4277 return 1;
4278 }
4279
4280
4281 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4282 PyObject *pyobj = 0;
4283
4284 {
4285 #if wxUSE_UNICODE
4286 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4287 #else
4288 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4289 #endif
4290 }
4291 return pyobj;
4292 }
4293
4294
4295 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4296 PyObject *resultobj = 0;
4297 wxSystemOptions *result = 0 ;
4298
4299 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4300 {
4301 PyThreadState* __tstate = wxPyBeginAllowThreads();
4302 result = (wxSystemOptions *)new wxSystemOptions();
4303 wxPyEndAllowThreads(__tstate);
4304 if (PyErr_Occurred()) SWIG_fail;
4305 }
4306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4307 return resultobj;
4308 fail:
4309 return NULL;
4310 }
4311
4312
4313 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4314 PyObject *resultobj = 0;
4315 wxString *arg1 = 0 ;
4316 wxString *arg2 = 0 ;
4317 bool temp1 = false ;
4318 bool temp2 = false ;
4319 PyObject * obj0 = 0 ;
4320 PyObject * obj1 = 0 ;
4321 char * kwnames[] = {
4322 (char *) "name",(char *) "value", NULL
4323 };
4324
4325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4326 {
4327 arg1 = wxString_in_helper(obj0);
4328 if (arg1 == NULL) SWIG_fail;
4329 temp1 = true;
4330 }
4331 {
4332 arg2 = wxString_in_helper(obj1);
4333 if (arg2 == NULL) SWIG_fail;
4334 temp2 = true;
4335 }
4336 {
4337 PyThreadState* __tstate = wxPyBeginAllowThreads();
4338 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4339 wxPyEndAllowThreads(__tstate);
4340 if (PyErr_Occurred()) SWIG_fail;
4341 }
4342 resultobj = SWIG_Py_Void();
4343 {
4344 if (temp1)
4345 delete arg1;
4346 }
4347 {
4348 if (temp2)
4349 delete arg2;
4350 }
4351 return resultobj;
4352 fail:
4353 {
4354 if (temp1)
4355 delete arg1;
4356 }
4357 {
4358 if (temp2)
4359 delete arg2;
4360 }
4361 return NULL;
4362 }
4363
4364
4365 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj = 0;
4367 wxString *arg1 = 0 ;
4368 int arg2 ;
4369 bool temp1 = false ;
4370 int val2 ;
4371 int ecode2 = 0 ;
4372 PyObject * obj0 = 0 ;
4373 PyObject * obj1 = 0 ;
4374 char * kwnames[] = {
4375 (char *) "name",(char *) "value", NULL
4376 };
4377
4378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4379 {
4380 arg1 = wxString_in_helper(obj0);
4381 if (arg1 == NULL) SWIG_fail;
4382 temp1 = true;
4383 }
4384 ecode2 = SWIG_AsVal_int(obj1, &val2);
4385 if (!SWIG_IsOK(ecode2)) {
4386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4387 }
4388 arg2 = static_cast< int >(val2);
4389 {
4390 PyThreadState* __tstate = wxPyBeginAllowThreads();
4391 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4392 wxPyEndAllowThreads(__tstate);
4393 if (PyErr_Occurred()) SWIG_fail;
4394 }
4395 resultobj = SWIG_Py_Void();
4396 {
4397 if (temp1)
4398 delete arg1;
4399 }
4400 return resultobj;
4401 fail:
4402 {
4403 if (temp1)
4404 delete arg1;
4405 }
4406 return NULL;
4407 }
4408
4409
4410 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4411 PyObject *resultobj = 0;
4412 wxString *arg1 = 0 ;
4413 wxString result;
4414 bool temp1 = false ;
4415 PyObject * obj0 = 0 ;
4416 char * kwnames[] = {
4417 (char *) "name", NULL
4418 };
4419
4420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4421 {
4422 arg1 = wxString_in_helper(obj0);
4423 if (arg1 == NULL) SWIG_fail;
4424 temp1 = true;
4425 }
4426 {
4427 PyThreadState* __tstate = wxPyBeginAllowThreads();
4428 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4429 wxPyEndAllowThreads(__tstate);
4430 if (PyErr_Occurred()) SWIG_fail;
4431 }
4432 {
4433 #if wxUSE_UNICODE
4434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4435 #else
4436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4437 #endif
4438 }
4439 {
4440 if (temp1)
4441 delete arg1;
4442 }
4443 return resultobj;
4444 fail:
4445 {
4446 if (temp1)
4447 delete arg1;
4448 }
4449 return NULL;
4450 }
4451
4452
4453 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4454 PyObject *resultobj = 0;
4455 wxString *arg1 = 0 ;
4456 int result;
4457 bool temp1 = false ;
4458 PyObject * obj0 = 0 ;
4459 char * kwnames[] = {
4460 (char *) "name", NULL
4461 };
4462
4463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4464 {
4465 arg1 = wxString_in_helper(obj0);
4466 if (arg1 == NULL) SWIG_fail;
4467 temp1 = true;
4468 }
4469 {
4470 PyThreadState* __tstate = wxPyBeginAllowThreads();
4471 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4472 wxPyEndAllowThreads(__tstate);
4473 if (PyErr_Occurred()) SWIG_fail;
4474 }
4475 resultobj = SWIG_From_int(static_cast< int >(result));
4476 {
4477 if (temp1)
4478 delete arg1;
4479 }
4480 return resultobj;
4481 fail:
4482 {
4483 if (temp1)
4484 delete arg1;
4485 }
4486 return NULL;
4487 }
4488
4489
4490 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4491 PyObject *resultobj = 0;
4492 wxString *arg1 = 0 ;
4493 bool result;
4494 bool temp1 = false ;
4495 PyObject * obj0 = 0 ;
4496 char * kwnames[] = {
4497 (char *) "name", NULL
4498 };
4499
4500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4501 {
4502 arg1 = wxString_in_helper(obj0);
4503 if (arg1 == NULL) SWIG_fail;
4504 temp1 = true;
4505 }
4506 {
4507 PyThreadState* __tstate = wxPyBeginAllowThreads();
4508 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4509 wxPyEndAllowThreads(__tstate);
4510 if (PyErr_Occurred()) SWIG_fail;
4511 }
4512 {
4513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4514 }
4515 {
4516 if (temp1)
4517 delete arg1;
4518 }
4519 return resultobj;
4520 fail:
4521 {
4522 if (temp1)
4523 delete arg1;
4524 }
4525 return NULL;
4526 }
4527
4528
4529 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4530 PyObject *resultobj = 0;
4531 wxString *arg1 = 0 ;
4532 bool result;
4533 bool temp1 = false ;
4534 PyObject * obj0 = 0 ;
4535 char * kwnames[] = {
4536 (char *) "name", NULL
4537 };
4538
4539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4540 {
4541 arg1 = wxString_in_helper(obj0);
4542 if (arg1 == NULL) SWIG_fail;
4543 temp1 = true;
4544 }
4545 {
4546 PyThreadState* __tstate = wxPyBeginAllowThreads();
4547 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4548 wxPyEndAllowThreads(__tstate);
4549 if (PyErr_Occurred()) SWIG_fail;
4550 }
4551 {
4552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4553 }
4554 {
4555 if (temp1)
4556 delete arg1;
4557 }
4558 return resultobj;
4559 fail:
4560 {
4561 if (temp1)
4562 delete arg1;
4563 }
4564 return NULL;
4565 }
4566
4567
4568 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4569 PyObject *obj;
4570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4571 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4572 return SWIG_Py_Void();
4573 }
4574
4575 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4576 return SWIG_Python_InitShadowInstance(args);
4577 }
4578
4579 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4580 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4581 return 1;
4582 }
4583
4584
4585 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4586 PyObject *pyobj = 0;
4587
4588 {
4589 #if wxUSE_UNICODE
4590 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4591 #else
4592 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4593 #endif
4594 }
4595 return pyobj;
4596 }
4597
4598
4599 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4600 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4601 return 1;
4602 }
4603
4604
4605 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4606 PyObject *pyobj = 0;
4607
4608 {
4609 #if wxUSE_UNICODE
4610 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4611 #else
4612 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4613 #endif
4614 }
4615 return pyobj;
4616 }
4617
4618
4619 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4620 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4621 return 1;
4622 }
4623
4624
4625 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4626 PyObject *pyobj = 0;
4627
4628 {
4629 #if wxUSE_UNICODE
4630 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4631 #else
4632 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4633 #endif
4634 }
4635 return pyobj;
4636 }
4637
4638
4639 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4640 PyObject *resultobj = 0;
4641 long result;
4642
4643 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 result = (long)wxNewId();
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 resultobj = SWIG_From_long(static_cast< long >(result));
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj = 0;
4659 long arg1 ;
4660 long val1 ;
4661 int ecode1 = 0 ;
4662 PyObject * obj0 = 0 ;
4663 char * kwnames[] = {
4664 (char *) "id", NULL
4665 };
4666
4667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4668 ecode1 = SWIG_AsVal_long(obj0, &val1);
4669 if (!SWIG_IsOK(ecode1)) {
4670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4671 }
4672 arg1 = static_cast< long >(val1);
4673 {
4674 PyThreadState* __tstate = wxPyBeginAllowThreads();
4675 wxRegisterId(arg1);
4676 wxPyEndAllowThreads(__tstate);
4677 if (PyErr_Occurred()) SWIG_fail;
4678 }
4679 resultobj = SWIG_Py_Void();
4680 return resultobj;
4681 fail:
4682 return NULL;
4683 }
4684
4685
4686 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4687 PyObject *resultobj = 0;
4688 long result;
4689
4690 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4691 {
4692 PyThreadState* __tstate = wxPyBeginAllowThreads();
4693 result = (long)wxGetCurrentId();
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 resultobj = SWIG_From_long(static_cast< long >(result));
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj = 0;
4706 int arg1 ;
4707 bool result;
4708 int val1 ;
4709 int ecode1 = 0 ;
4710 PyObject * obj0 = 0 ;
4711 char * kwnames[] = {
4712 (char *) "id", NULL
4713 };
4714
4715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4716 ecode1 = SWIG_AsVal_int(obj0, &val1);
4717 if (!SWIG_IsOK(ecode1)) {
4718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4719 }
4720 arg1 = static_cast< int >(val1);
4721 {
4722 PyThreadState* __tstate = wxPyBeginAllowThreads();
4723 result = (bool)wxIsStockID(arg1);
4724 wxPyEndAllowThreads(__tstate);
4725 if (PyErr_Occurred()) SWIG_fail;
4726 }
4727 {
4728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4729 }
4730 return resultobj;
4731 fail:
4732 return NULL;
4733 }
4734
4735
4736 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4737 PyObject *resultobj = 0;
4738 int arg1 ;
4739 wxString *arg2 = 0 ;
4740 bool result;
4741 int val1 ;
4742 int ecode1 = 0 ;
4743 bool temp2 = false ;
4744 PyObject * obj0 = 0 ;
4745 PyObject * obj1 = 0 ;
4746 char * kwnames[] = {
4747 (char *) "id",(char *) "label", NULL
4748 };
4749
4750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4751 ecode1 = SWIG_AsVal_int(obj0, &val1);
4752 if (!SWIG_IsOK(ecode1)) {
4753 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4754 }
4755 arg1 = static_cast< int >(val1);
4756 {
4757 arg2 = wxString_in_helper(obj1);
4758 if (arg2 == NULL) SWIG_fail;
4759 temp2 = true;
4760 }
4761 {
4762 PyThreadState* __tstate = wxPyBeginAllowThreads();
4763 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4764 wxPyEndAllowThreads(__tstate);
4765 if (PyErr_Occurred()) SWIG_fail;
4766 }
4767 {
4768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4769 }
4770 {
4771 if (temp2)
4772 delete arg2;
4773 }
4774 return resultobj;
4775 fail:
4776 {
4777 if (temp2)
4778 delete arg2;
4779 }
4780 return NULL;
4781 }
4782
4783
4784 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj = 0;
4786 int arg1 ;
4787 bool arg2 = (bool) true ;
4788 wxString arg3 = (wxString) wxPyEmptyString ;
4789 wxString result;
4790 int val1 ;
4791 int ecode1 = 0 ;
4792 bool val2 ;
4793 int ecode2 = 0 ;
4794 PyObject * obj0 = 0 ;
4795 PyObject * obj1 = 0 ;
4796 PyObject * obj2 = 0 ;
4797 char * kwnames[] = {
4798 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4799 };
4800
4801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4802 ecode1 = SWIG_AsVal_int(obj0, &val1);
4803 if (!SWIG_IsOK(ecode1)) {
4804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4805 }
4806 arg1 = static_cast< int >(val1);
4807 if (obj1) {
4808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4809 if (!SWIG_IsOK(ecode2)) {
4810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4811 }
4812 arg2 = static_cast< bool >(val2);
4813 }
4814 if (obj2) {
4815 {
4816 wxString* sptr = wxString_in_helper(obj2);
4817 if (sptr == NULL) SWIG_fail;
4818 arg3 = *sptr;
4819 delete sptr;
4820 }
4821 }
4822 {
4823 PyThreadState* __tstate = wxPyBeginAllowThreads();
4824 result = wxGetStockLabel(arg1,arg2,arg3);
4825 wxPyEndAllowThreads(__tstate);
4826 if (PyErr_Occurred()) SWIG_fail;
4827 }
4828 {
4829 #if wxUSE_UNICODE
4830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4831 #else
4832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4833 #endif
4834 }
4835 return resultobj;
4836 fail:
4837 return NULL;
4838 }
4839
4840
4841 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4842 PyObject *resultobj = 0;
4843
4844 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4845 {
4846 if (!wxPyCheckForApp()) SWIG_fail;
4847 PyThreadState* __tstate = wxPyBeginAllowThreads();
4848 wxBell();
4849 wxPyEndAllowThreads(__tstate);
4850 if (PyErr_Occurred()) SWIG_fail;
4851 }
4852 resultobj = SWIG_Py_Void();
4853 return resultobj;
4854 fail:
4855 return NULL;
4856 }
4857
4858
4859 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4860 PyObject *resultobj = 0;
4861
4862 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4863 {
4864 if (!wxPyCheckForApp()) SWIG_fail;
4865 PyThreadState* __tstate = wxPyBeginAllowThreads();
4866 wxEndBusyCursor();
4867 wxPyEndAllowThreads(__tstate);
4868 if (PyErr_Occurred()) SWIG_fail;
4869 }
4870 resultobj = SWIG_Py_Void();
4871 return resultobj;
4872 fail:
4873 return NULL;
4874 }
4875
4876
4877 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4878 PyObject *resultobj = 0;
4879 bool arg1 = (bool) true ;
4880 long result;
4881 bool val1 ;
4882 int ecode1 = 0 ;
4883 PyObject * obj0 = 0 ;
4884 char * kwnames[] = {
4885 (char *) "resetTimer", NULL
4886 };
4887
4888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4889 if (obj0) {
4890 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4891 if (!SWIG_IsOK(ecode1)) {
4892 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4893 }
4894 arg1 = static_cast< bool >(val1);
4895 }
4896 {
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 result = (long)wxGetElapsedTime(arg1);
4899 wxPyEndAllowThreads(__tstate);
4900 if (PyErr_Occurred()) SWIG_fail;
4901 }
4902 resultobj = SWIG_From_long(static_cast< long >(result));
4903 return resultobj;
4904 fail:
4905 return NULL;
4906 }
4907
4908
4909 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4910 PyObject *resultobj = 0;
4911 bool result;
4912
4913 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4914 {
4915 PyThreadState* __tstate = wxPyBeginAllowThreads();
4916 result = (bool)wxIsBusy();
4917 wxPyEndAllowThreads(__tstate);
4918 if (PyErr_Occurred()) SWIG_fail;
4919 }
4920 {
4921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4922 }
4923 return resultobj;
4924 fail:
4925 return NULL;
4926 }
4927
4928
4929 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4930 PyObject *resultobj = 0;
4931 wxString result;
4932
4933 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4934 {
4935 PyThreadState* __tstate = wxPyBeginAllowThreads();
4936 result = wxNow();
4937 wxPyEndAllowThreads(__tstate);
4938 if (PyErr_Occurred()) SWIG_fail;
4939 }
4940 {
4941 #if wxUSE_UNICODE
4942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4943 #else
4944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4945 #endif
4946 }
4947 return resultobj;
4948 fail:
4949 return NULL;
4950 }
4951
4952
4953 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4954 PyObject *resultobj = 0;
4955 wxString const &arg1_defvalue = wxPyEmptyString ;
4956 wxString *arg1 = (wxString *) &arg1_defvalue ;
4957 bool result;
4958 bool temp1 = false ;
4959 PyObject * obj0 = 0 ;
4960 char * kwnames[] = {
4961 (char *) "command", NULL
4962 };
4963
4964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4965 if (obj0) {
4966 {
4967 arg1 = wxString_in_helper(obj0);
4968 if (arg1 == NULL) SWIG_fail;
4969 temp1 = true;
4970 }
4971 }
4972 {
4973 PyThreadState* __tstate = wxPyBeginAllowThreads();
4974 result = (bool)wxShell((wxString const &)*arg1);
4975 wxPyEndAllowThreads(__tstate);
4976 if (PyErr_Occurred()) SWIG_fail;
4977 }
4978 {
4979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4980 }
4981 {
4982 if (temp1)
4983 delete arg1;
4984 }
4985 return resultobj;
4986 fail:
4987 {
4988 if (temp1)
4989 delete arg1;
4990 }
4991 return NULL;
4992 }
4993
4994
4995 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4996 PyObject *resultobj = 0;
4997
4998 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
4999 {
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 wxStartTimer();
5002 wxPyEndAllowThreads(__tstate);
5003 if (PyErr_Occurred()) SWIG_fail;
5004 }
5005 resultobj = SWIG_Py_Void();
5006 return resultobj;
5007 fail:
5008 return NULL;
5009 }
5010
5011
5012 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5013 PyObject *resultobj = 0;
5014 int *arg1 = (int *) 0 ;
5015 int *arg2 = (int *) 0 ;
5016 int result;
5017 int temp1 ;
5018 int res1 = SWIG_TMPOBJ ;
5019 int temp2 ;
5020 int res2 = SWIG_TMPOBJ ;
5021
5022 arg1 = &temp1;
5023 arg2 = &temp2;
5024 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5025 {
5026 PyThreadState* __tstate = wxPyBeginAllowThreads();
5027 result = (int)wxGetOsVersion(arg1,arg2);
5028 wxPyEndAllowThreads(__tstate);
5029 if (PyErr_Occurred()) SWIG_fail;
5030 }
5031 resultobj = SWIG_From_int(static_cast< int >(result));
5032 if (SWIG_IsTmpObj(res1)) {
5033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5034 } else {
5035 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5037 }
5038 if (SWIG_IsTmpObj(res2)) {
5039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5040 } else {
5041 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5043 }
5044 return resultobj;
5045 fail:
5046 return NULL;
5047 }
5048
5049
5050 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5051 PyObject *resultobj = 0;
5052 wxString result;
5053
5054 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5055 {
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 result = wxGetOsDescription();
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 {
5062 #if wxUSE_UNICODE
5063 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5064 #else
5065 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5066 #endif
5067 }
5068 return resultobj;
5069 fail:
5070 return NULL;
5071 }
5072
5073
5074 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5075 PyObject *resultobj = 0;
5076 wxMemorySize result;
5077
5078 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5079 {
5080 PyThreadState* __tstate = wxPyBeginAllowThreads();
5081 result = wxGetFreeMemory();
5082 wxPyEndAllowThreads(__tstate);
5083 if (PyErr_Occurred()) SWIG_fail;
5084 }
5085 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5086 return resultobj;
5087 fail:
5088 return NULL;
5089 }
5090
5091
5092 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5093 PyObject *resultobj = 0;
5094 wxShutdownFlags arg1 ;
5095 bool result;
5096 int val1 ;
5097 int ecode1 = 0 ;
5098 PyObject * obj0 = 0 ;
5099 char * kwnames[] = {
5100 (char *) "wFlags", NULL
5101 };
5102
5103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5104 ecode1 = SWIG_AsVal_int(obj0, &val1);
5105 if (!SWIG_IsOK(ecode1)) {
5106 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5107 }
5108 arg1 = static_cast< wxShutdownFlags >(val1);
5109 {
5110 if (!wxPyCheckForApp()) SWIG_fail;
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 result = (bool)wxShutdown(arg1);
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 {
5117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5118 }
5119 return resultobj;
5120 fail:
5121 return NULL;
5122 }
5123
5124
5125 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj = 0;
5127 int arg1 ;
5128 int val1 ;
5129 int ecode1 = 0 ;
5130 PyObject * obj0 = 0 ;
5131 char * kwnames[] = {
5132 (char *) "secs", NULL
5133 };
5134
5135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5136 ecode1 = SWIG_AsVal_int(obj0, &val1);
5137 if (!SWIG_IsOK(ecode1)) {
5138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5139 }
5140 arg1 = static_cast< int >(val1);
5141 {
5142 PyThreadState* __tstate = wxPyBeginAllowThreads();
5143 wxSleep(arg1);
5144 wxPyEndAllowThreads(__tstate);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 resultobj = SWIG_Py_Void();
5148 return resultobj;
5149 fail:
5150 return NULL;
5151 }
5152
5153
5154 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5155 PyObject *resultobj = 0;
5156 unsigned long arg1 ;
5157 unsigned long val1 ;
5158 int ecode1 = 0 ;
5159 PyObject * obj0 = 0 ;
5160 char * kwnames[] = {
5161 (char *) "milliseconds", NULL
5162 };
5163
5164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5165 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5166 if (!SWIG_IsOK(ecode1)) {
5167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5168 }
5169 arg1 = static_cast< unsigned long >(val1);
5170 {
5171 PyThreadState* __tstate = wxPyBeginAllowThreads();
5172 wxMilliSleep(arg1);
5173 wxPyEndAllowThreads(__tstate);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 resultobj = SWIG_Py_Void();
5177 return resultobj;
5178 fail:
5179 return NULL;
5180 }
5181
5182
5183 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5184 PyObject *resultobj = 0;
5185 unsigned long arg1 ;
5186 unsigned long val1 ;
5187 int ecode1 = 0 ;
5188 PyObject * obj0 = 0 ;
5189 char * kwnames[] = {
5190 (char *) "microseconds", NULL
5191 };
5192
5193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5194 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5195 if (!SWIG_IsOK(ecode1)) {
5196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5197 }
5198 arg1 = static_cast< unsigned long >(val1);
5199 {
5200 PyThreadState* __tstate = wxPyBeginAllowThreads();
5201 wxMicroSleep(arg1);
5202 wxPyEndAllowThreads(__tstate);
5203 if (PyErr_Occurred()) SWIG_fail;
5204 }
5205 resultobj = SWIG_Py_Void();
5206 return resultobj;
5207 fail:
5208 return NULL;
5209 }
5210
5211
5212 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5213 PyObject *resultobj = 0;
5214 bool arg1 ;
5215 bool val1 ;
5216 int ecode1 = 0 ;
5217 PyObject * obj0 = 0 ;
5218 char * kwnames[] = {
5219 (char *) "enable", NULL
5220 };
5221
5222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5223 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5224 if (!SWIG_IsOK(ecode1)) {
5225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5226 }
5227 arg1 = static_cast< bool >(val1);
5228 {
5229 PyThreadState* __tstate = wxPyBeginAllowThreads();
5230 wxEnableTopLevelWindows(arg1);
5231 wxPyEndAllowThreads(__tstate);
5232 if (PyErr_Occurred()) SWIG_fail;
5233 }
5234 resultobj = SWIG_Py_Void();
5235 return resultobj;
5236 fail:
5237 return NULL;
5238 }
5239
5240
5241 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5242 PyObject *resultobj = 0;
5243 wxString *arg1 = 0 ;
5244 wxString result;
5245 bool temp1 = false ;
5246 PyObject * obj0 = 0 ;
5247 char * kwnames[] = {
5248 (char *) "in", NULL
5249 };
5250
5251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5252 {
5253 arg1 = wxString_in_helper(obj0);
5254 if (arg1 == NULL) SWIG_fail;
5255 temp1 = true;
5256 }
5257 {
5258 PyThreadState* __tstate = wxPyBeginAllowThreads();
5259 result = wxStripMenuCodes((wxString const &)*arg1);
5260 wxPyEndAllowThreads(__tstate);
5261 if (PyErr_Occurred()) SWIG_fail;
5262 }
5263 {
5264 #if wxUSE_UNICODE
5265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5266 #else
5267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5268 #endif
5269 }
5270 {
5271 if (temp1)
5272 delete arg1;
5273 }
5274 return resultobj;
5275 fail:
5276 {
5277 if (temp1)
5278 delete arg1;
5279 }
5280 return NULL;
5281 }
5282
5283
5284 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5285 PyObject *resultobj = 0;
5286 wxString result;
5287
5288 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5289 {
5290 PyThreadState* __tstate = wxPyBeginAllowThreads();
5291 result = wxGetEmailAddress();
5292 wxPyEndAllowThreads(__tstate);
5293 if (PyErr_Occurred()) SWIG_fail;
5294 }
5295 {
5296 #if wxUSE_UNICODE
5297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5298 #else
5299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5300 #endif
5301 }
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5309 PyObject *resultobj = 0;
5310 wxString result;
5311
5312 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5313 {
5314 PyThreadState* __tstate = wxPyBeginAllowThreads();
5315 result = wxGetHostName();
5316 wxPyEndAllowThreads(__tstate);
5317 if (PyErr_Occurred()) SWIG_fail;
5318 }
5319 {
5320 #if wxUSE_UNICODE
5321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5322 #else
5323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5324 #endif
5325 }
5326 return resultobj;
5327 fail:
5328 return NULL;
5329 }
5330
5331
5332 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5333 PyObject *resultobj = 0;
5334 wxString result;
5335
5336 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5337 {
5338 PyThreadState* __tstate = wxPyBeginAllowThreads();
5339 result = wxGetFullHostName();
5340 wxPyEndAllowThreads(__tstate);
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 {
5344 #if wxUSE_UNICODE
5345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5346 #else
5347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5348 #endif
5349 }
5350 return resultobj;
5351 fail:
5352 return NULL;
5353 }
5354
5355
5356 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5357 PyObject *resultobj = 0;
5358 wxString result;
5359
5360 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5361 {
5362 PyThreadState* __tstate = wxPyBeginAllowThreads();
5363 result = wxGetUserId();
5364 wxPyEndAllowThreads(__tstate);
5365 if (PyErr_Occurred()) SWIG_fail;
5366 }
5367 {
5368 #if wxUSE_UNICODE
5369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5370 #else
5371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5372 #endif
5373 }
5374 return resultobj;
5375 fail:
5376 return NULL;
5377 }
5378
5379
5380 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5381 PyObject *resultobj = 0;
5382 wxString result;
5383
5384 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5385 {
5386 PyThreadState* __tstate = wxPyBeginAllowThreads();
5387 result = wxGetUserName();
5388 wxPyEndAllowThreads(__tstate);
5389 if (PyErr_Occurred()) SWIG_fail;
5390 }
5391 {
5392 #if wxUSE_UNICODE
5393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5394 #else
5395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5396 #endif
5397 }
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5405 PyObject *resultobj = 0;
5406 wxString result;
5407
5408 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5409 {
5410 PyThreadState* __tstate = wxPyBeginAllowThreads();
5411 result = wxGetHomeDir();
5412 wxPyEndAllowThreads(__tstate);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 {
5416 #if wxUSE_UNICODE
5417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5418 #else
5419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5420 #endif
5421 }
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5429 PyObject *resultobj = 0;
5430 wxString const &arg1_defvalue = wxPyEmptyString ;
5431 wxString *arg1 = (wxString *) &arg1_defvalue ;
5432 wxString result;
5433 bool temp1 = false ;
5434 PyObject * obj0 = 0 ;
5435 char * kwnames[] = {
5436 (char *) "user", NULL
5437 };
5438
5439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5440 if (obj0) {
5441 {
5442 arg1 = wxString_in_helper(obj0);
5443 if (arg1 == NULL) SWIG_fail;
5444 temp1 = true;
5445 }
5446 }
5447 {
5448 PyThreadState* __tstate = wxPyBeginAllowThreads();
5449 result = wxGetUserHome((wxString const &)*arg1);
5450 wxPyEndAllowThreads(__tstate);
5451 if (PyErr_Occurred()) SWIG_fail;
5452 }
5453 {
5454 #if wxUSE_UNICODE
5455 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5456 #else
5457 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5458 #endif
5459 }
5460 {
5461 if (temp1)
5462 delete arg1;
5463 }
5464 return resultobj;
5465 fail:
5466 {
5467 if (temp1)
5468 delete arg1;
5469 }
5470 return NULL;
5471 }
5472
5473
5474 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5475 PyObject *resultobj = 0;
5476 unsigned long result;
5477
5478 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5479 {
5480 PyThreadState* __tstate = wxPyBeginAllowThreads();
5481 result = (unsigned long)wxGetProcessId();
5482 wxPyEndAllowThreads(__tstate);
5483 if (PyErr_Occurred()) SWIG_fail;
5484 }
5485 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5486 return resultobj;
5487 fail:
5488 return NULL;
5489 }
5490
5491
5492 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5493 PyObject *resultobj = 0;
5494
5495 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5496 {
5497 PyThreadState* __tstate = wxPyBeginAllowThreads();
5498 wxTrap();
5499 wxPyEndAllowThreads(__tstate);
5500 if (PyErr_Occurred()) SWIG_fail;
5501 }
5502 resultobj = SWIG_Py_Void();
5503 return resultobj;
5504 fail:
5505 return NULL;
5506 }
5507
5508
5509 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5510 PyObject *resultobj = 0;
5511 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5512 wxString *arg1 = (wxString *) &arg1_defvalue ;
5513 wxString const &arg2_defvalue = wxPyEmptyString ;
5514 wxString *arg2 = (wxString *) &arg2_defvalue ;
5515 wxString const &arg3_defvalue = wxPyEmptyString ;
5516 wxString *arg3 = (wxString *) &arg3_defvalue ;
5517 wxString const &arg4_defvalue = wxPyEmptyString ;
5518 wxString *arg4 = (wxString *) &arg4_defvalue ;
5519 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5520 wxString *arg5 = (wxString *) &arg5_defvalue ;
5521 int arg6 = (int) 0 ;
5522 wxWindow *arg7 = (wxWindow *) NULL ;
5523 int arg8 = (int) -1 ;
5524 int arg9 = (int) -1 ;
5525 wxString result;
5526 bool temp1 = false ;
5527 bool temp2 = false ;
5528 bool temp3 = false ;
5529 bool temp4 = false ;
5530 bool temp5 = false ;
5531 int val6 ;
5532 int ecode6 = 0 ;
5533 void *argp7 = 0 ;
5534 int res7 = 0 ;
5535 int val8 ;
5536 int ecode8 = 0 ;
5537 int val9 ;
5538 int ecode9 = 0 ;
5539 PyObject * obj0 = 0 ;
5540 PyObject * obj1 = 0 ;
5541 PyObject * obj2 = 0 ;
5542 PyObject * obj3 = 0 ;
5543 PyObject * obj4 = 0 ;
5544 PyObject * obj5 = 0 ;
5545 PyObject * obj6 = 0 ;
5546 PyObject * obj7 = 0 ;
5547 PyObject * obj8 = 0 ;
5548 char * kwnames[] = {
5549 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5550 };
5551
5552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5553 if (obj0) {
5554 {
5555 arg1 = wxString_in_helper(obj0);
5556 if (arg1 == NULL) SWIG_fail;
5557 temp1 = true;
5558 }
5559 }
5560 if (obj1) {
5561 {
5562 arg2 = wxString_in_helper(obj1);
5563 if (arg2 == NULL) SWIG_fail;
5564 temp2 = true;
5565 }
5566 }
5567 if (obj2) {
5568 {
5569 arg3 = wxString_in_helper(obj2);
5570 if (arg3 == NULL) SWIG_fail;
5571 temp3 = true;
5572 }
5573 }
5574 if (obj3) {
5575 {
5576 arg4 = wxString_in_helper(obj3);
5577 if (arg4 == NULL) SWIG_fail;
5578 temp4 = true;
5579 }
5580 }
5581 if (obj4) {
5582 {
5583 arg5 = wxString_in_helper(obj4);
5584 if (arg5 == NULL) SWIG_fail;
5585 temp5 = true;
5586 }
5587 }
5588 if (obj5) {
5589 ecode6 = SWIG_AsVal_int(obj5, &val6);
5590 if (!SWIG_IsOK(ecode6)) {
5591 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5592 }
5593 arg6 = static_cast< int >(val6);
5594 }
5595 if (obj6) {
5596 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5597 if (!SWIG_IsOK(res7)) {
5598 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5599 }
5600 arg7 = reinterpret_cast< wxWindow * >(argp7);
5601 }
5602 if (obj7) {
5603 ecode8 = SWIG_AsVal_int(obj7, &val8);
5604 if (!SWIG_IsOK(ecode8)) {
5605 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5606 }
5607 arg8 = static_cast< int >(val8);
5608 }
5609 if (obj8) {
5610 ecode9 = SWIG_AsVal_int(obj8, &val9);
5611 if (!SWIG_IsOK(ecode9)) {
5612 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5613 }
5614 arg9 = static_cast< int >(val9);
5615 }
5616 {
5617 if (!wxPyCheckForApp()) SWIG_fail;
5618 PyThreadState* __tstate = wxPyBeginAllowThreads();
5619 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5620 wxPyEndAllowThreads(__tstate);
5621 if (PyErr_Occurred()) SWIG_fail;
5622 }
5623 {
5624 #if wxUSE_UNICODE
5625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5626 #else
5627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5628 #endif
5629 }
5630 {
5631 if (temp1)
5632 delete arg1;
5633 }
5634 {
5635 if (temp2)
5636 delete arg2;
5637 }
5638 {
5639 if (temp3)
5640 delete arg3;
5641 }
5642 {
5643 if (temp4)
5644 delete arg4;
5645 }
5646 {
5647 if (temp5)
5648 delete arg5;
5649 }
5650 return resultobj;
5651 fail:
5652 {
5653 if (temp1)
5654 delete arg1;
5655 }
5656 {
5657 if (temp2)
5658 delete arg2;
5659 }
5660 {
5661 if (temp3)
5662 delete arg3;
5663 }
5664 {
5665 if (temp4)
5666 delete arg4;
5667 }
5668 {
5669 if (temp5)
5670 delete arg5;
5671 }
5672 return NULL;
5673 }
5674
5675
5676 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5677 PyObject *resultobj = 0;
5678 wxString *arg1 = 0 ;
5679 wxString *arg2 = 0 ;
5680 wxString const &arg3_defvalue = wxPyEmptyString ;
5681 wxString *arg3 = (wxString *) &arg3_defvalue ;
5682 wxWindow *arg4 = (wxWindow *) NULL ;
5683 wxString result;
5684 bool temp1 = false ;
5685 bool temp2 = false ;
5686 bool temp3 = false ;
5687 void *argp4 = 0 ;
5688 int res4 = 0 ;
5689 PyObject * obj0 = 0 ;
5690 PyObject * obj1 = 0 ;
5691 PyObject * obj2 = 0 ;
5692 PyObject * obj3 = 0 ;
5693 char * kwnames[] = {
5694 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5695 };
5696
5697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5698 {
5699 arg1 = wxString_in_helper(obj0);
5700 if (arg1 == NULL) SWIG_fail;
5701 temp1 = true;
5702 }
5703 {
5704 arg2 = wxString_in_helper(obj1);
5705 if (arg2 == NULL) SWIG_fail;
5706 temp2 = true;
5707 }
5708 if (obj2) {
5709 {
5710 arg3 = wxString_in_helper(obj2);
5711 if (arg3 == NULL) SWIG_fail;
5712 temp3 = true;
5713 }
5714 }
5715 if (obj3) {
5716 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5717 if (!SWIG_IsOK(res4)) {
5718 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5719 }
5720 arg4 = reinterpret_cast< wxWindow * >(argp4);
5721 }
5722 {
5723 if (!wxPyCheckForApp()) SWIG_fail;
5724 PyThreadState* __tstate = wxPyBeginAllowThreads();
5725 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5726 wxPyEndAllowThreads(__tstate);
5727 if (PyErr_Occurred()) SWIG_fail;
5728 }
5729 {
5730 #if wxUSE_UNICODE
5731 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5732 #else
5733 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5734 #endif
5735 }
5736 {
5737 if (temp1)
5738 delete arg1;
5739 }
5740 {
5741 if (temp2)
5742 delete arg2;
5743 }
5744 {
5745 if (temp3)
5746 delete arg3;
5747 }
5748 return resultobj;
5749 fail:
5750 {
5751 if (temp1)
5752 delete arg1;
5753 }
5754 {
5755 if (temp2)
5756 delete arg2;
5757 }
5758 {
5759 if (temp3)
5760 delete arg3;
5761 }
5762 return NULL;
5763 }
5764
5765
5766 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5767 PyObject *resultobj = 0;
5768 wxString *arg1 = 0 ;
5769 wxString *arg2 = 0 ;
5770 wxString const &arg3_defvalue = wxPyEmptyString ;
5771 wxString *arg3 = (wxString *) &arg3_defvalue ;
5772 wxWindow *arg4 = (wxWindow *) NULL ;
5773 wxString result;
5774 bool temp1 = false ;
5775 bool temp2 = false ;
5776 bool temp3 = false ;
5777 void *argp4 = 0 ;
5778 int res4 = 0 ;
5779 PyObject * obj0 = 0 ;
5780 PyObject * obj1 = 0 ;
5781 PyObject * obj2 = 0 ;
5782 PyObject * obj3 = 0 ;
5783 char * kwnames[] = {
5784 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5785 };
5786
5787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5788 {
5789 arg1 = wxString_in_helper(obj0);
5790 if (arg1 == NULL) SWIG_fail;
5791 temp1 = true;
5792 }
5793 {
5794 arg2 = wxString_in_helper(obj1);
5795 if (arg2 == NULL) SWIG_fail;
5796 temp2 = true;
5797 }
5798 if (obj2) {
5799 {
5800 arg3 = wxString_in_helper(obj2);
5801 if (arg3 == NULL) SWIG_fail;
5802 temp3 = true;
5803 }
5804 }
5805 if (obj3) {
5806 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5807 if (!SWIG_IsOK(res4)) {
5808 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5809 }
5810 arg4 = reinterpret_cast< wxWindow * >(argp4);
5811 }
5812 {
5813 if (!wxPyCheckForApp()) SWIG_fail;
5814 PyThreadState* __tstate = wxPyBeginAllowThreads();
5815 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5816 wxPyEndAllowThreads(__tstate);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 {
5820 #if wxUSE_UNICODE
5821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5822 #else
5823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5824 #endif
5825 }
5826 {
5827 if (temp1)
5828 delete arg1;
5829 }
5830 {
5831 if (temp2)
5832 delete arg2;
5833 }
5834 {
5835 if (temp3)
5836 delete arg3;
5837 }
5838 return resultobj;
5839 fail:
5840 {
5841 if (temp1)
5842 delete arg1;
5843 }
5844 {
5845 if (temp2)
5846 delete arg2;
5847 }
5848 {
5849 if (temp3)
5850 delete arg3;
5851 }
5852 return NULL;
5853 }
5854
5855
5856 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5857 PyObject *resultobj = 0;
5858 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5859 wxString *arg1 = (wxString *) &arg1_defvalue ;
5860 wxString const &arg2_defvalue = wxPyEmptyString ;
5861 wxString *arg2 = (wxString *) &arg2_defvalue ;
5862 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5863 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5864 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5865 wxWindow *arg5 = (wxWindow *) NULL ;
5866 wxString result;
5867 bool temp1 = false ;
5868 bool temp2 = false ;
5869 long val3 ;
5870 int ecode3 = 0 ;
5871 wxPoint temp4 ;
5872 void *argp5 = 0 ;
5873 int res5 = 0 ;
5874 PyObject * obj0 = 0 ;
5875 PyObject * obj1 = 0 ;
5876 PyObject * obj2 = 0 ;
5877 PyObject * obj3 = 0 ;
5878 PyObject * obj4 = 0 ;
5879 char * kwnames[] = {
5880 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5881 };
5882
5883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5884 if (obj0) {
5885 {
5886 arg1 = wxString_in_helper(obj0);
5887 if (arg1 == NULL) SWIG_fail;
5888 temp1 = true;
5889 }
5890 }
5891 if (obj1) {
5892 {
5893 arg2 = wxString_in_helper(obj1);
5894 if (arg2 == NULL) SWIG_fail;
5895 temp2 = true;
5896 }
5897 }
5898 if (obj2) {
5899 ecode3 = SWIG_AsVal_long(obj2, &val3);
5900 if (!SWIG_IsOK(ecode3)) {
5901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5902 }
5903 arg3 = static_cast< long >(val3);
5904 }
5905 if (obj3) {
5906 {
5907 arg4 = &temp4;
5908 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5909 }
5910 }
5911 if (obj4) {
5912 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5913 if (!SWIG_IsOK(res5)) {
5914 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5915 }
5916 arg5 = reinterpret_cast< wxWindow * >(argp5);
5917 }
5918 {
5919 if (!wxPyCheckForApp()) SWIG_fail;
5920 PyThreadState* __tstate = wxPyBeginAllowThreads();
5921 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5922 wxPyEndAllowThreads(__tstate);
5923 if (PyErr_Occurred()) SWIG_fail;
5924 }
5925 {
5926 #if wxUSE_UNICODE
5927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5928 #else
5929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5930 #endif
5931 }
5932 {
5933 if (temp1)
5934 delete arg1;
5935 }
5936 {
5937 if (temp2)
5938 delete arg2;
5939 }
5940 return resultobj;
5941 fail:
5942 {
5943 if (temp1)
5944 delete arg1;
5945 }
5946 {
5947 if (temp2)
5948 delete arg2;
5949 }
5950 return NULL;
5951 }
5952
5953
5954 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5955 PyObject *resultobj = 0;
5956 wxString *arg1 = 0 ;
5957 wxString const &arg2_defvalue = wxPyEmptyString ;
5958 wxString *arg2 = (wxString *) &arg2_defvalue ;
5959 wxString const &arg3_defvalue = wxPyEmptyString ;
5960 wxString *arg3 = (wxString *) &arg3_defvalue ;
5961 wxWindow *arg4 = (wxWindow *) NULL ;
5962 int arg5 = (int) -1 ;
5963 int arg6 = (int) -1 ;
5964 bool arg7 = (bool) true ;
5965 wxString result;
5966 bool temp1 = false ;
5967 bool temp2 = false ;
5968 bool temp3 = false ;
5969 void *argp4 = 0 ;
5970 int res4 = 0 ;
5971 int val5 ;
5972 int ecode5 = 0 ;
5973 int val6 ;
5974 int ecode6 = 0 ;
5975 bool val7 ;
5976 int ecode7 = 0 ;
5977 PyObject * obj0 = 0 ;
5978 PyObject * obj1 = 0 ;
5979 PyObject * obj2 = 0 ;
5980 PyObject * obj3 = 0 ;
5981 PyObject * obj4 = 0 ;
5982 PyObject * obj5 = 0 ;
5983 PyObject * obj6 = 0 ;
5984 char * kwnames[] = {
5985 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5986 };
5987
5988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5989 {
5990 arg1 = wxString_in_helper(obj0);
5991 if (arg1 == NULL) SWIG_fail;
5992 temp1 = true;
5993 }
5994 if (obj1) {
5995 {
5996 arg2 = wxString_in_helper(obj1);
5997 if (arg2 == NULL) SWIG_fail;
5998 temp2 = true;
5999 }
6000 }
6001 if (obj2) {
6002 {
6003 arg3 = wxString_in_helper(obj2);
6004 if (arg3 == NULL) SWIG_fail;
6005 temp3 = true;
6006 }
6007 }
6008 if (obj3) {
6009 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6010 if (!SWIG_IsOK(res4)) {
6011 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6012 }
6013 arg4 = reinterpret_cast< wxWindow * >(argp4);
6014 }
6015 if (obj4) {
6016 ecode5 = SWIG_AsVal_int(obj4, &val5);
6017 if (!SWIG_IsOK(ecode5)) {
6018 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6019 }
6020 arg5 = static_cast< int >(val5);
6021 }
6022 if (obj5) {
6023 ecode6 = SWIG_AsVal_int(obj5, &val6);
6024 if (!SWIG_IsOK(ecode6)) {
6025 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6026 }
6027 arg6 = static_cast< int >(val6);
6028 }
6029 if (obj6) {
6030 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6031 if (!SWIG_IsOK(ecode7)) {
6032 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6033 }
6034 arg7 = static_cast< bool >(val7);
6035 }
6036 {
6037 if (!wxPyCheckForApp()) SWIG_fail;
6038 PyThreadState* __tstate = wxPyBeginAllowThreads();
6039 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6040 wxPyEndAllowThreads(__tstate);
6041 if (PyErr_Occurred()) SWIG_fail;
6042 }
6043 {
6044 #if wxUSE_UNICODE
6045 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6046 #else
6047 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6048 #endif
6049 }
6050 {
6051 if (temp1)
6052 delete arg1;
6053 }
6054 {
6055 if (temp2)
6056 delete arg2;
6057 }
6058 {
6059 if (temp3)
6060 delete arg3;
6061 }
6062 return resultobj;
6063 fail:
6064 {
6065 if (temp1)
6066 delete arg1;
6067 }
6068 {
6069 if (temp2)
6070 delete arg2;
6071 }
6072 {
6073 if (temp3)
6074 delete arg3;
6075 }
6076 return NULL;
6077 }
6078
6079
6080 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6081 PyObject *resultobj = 0;
6082 wxString *arg1 = 0 ;
6083 wxString const &arg2_defvalue = wxPyEmptyString ;
6084 wxString *arg2 = (wxString *) &arg2_defvalue ;
6085 wxString const &arg3_defvalue = wxPyEmptyString ;
6086 wxString *arg3 = (wxString *) &arg3_defvalue ;
6087 wxWindow *arg4 = (wxWindow *) NULL ;
6088 wxString result;
6089 bool temp1 = false ;
6090 bool temp2 = false ;
6091 bool temp3 = false ;
6092 void *argp4 = 0 ;
6093 int res4 = 0 ;
6094 PyObject * obj0 = 0 ;
6095 PyObject * obj1 = 0 ;
6096 PyObject * obj2 = 0 ;
6097 PyObject * obj3 = 0 ;
6098 char * kwnames[] = {
6099 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6100 };
6101
6102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6103 {
6104 arg1 = wxString_in_helper(obj0);
6105 if (arg1 == NULL) SWIG_fail;
6106 temp1 = true;
6107 }
6108 if (obj1) {
6109 {
6110 arg2 = wxString_in_helper(obj1);
6111 if (arg2 == NULL) SWIG_fail;
6112 temp2 = true;
6113 }
6114 }
6115 if (obj2) {
6116 {
6117 arg3 = wxString_in_helper(obj2);
6118 if (arg3 == NULL) SWIG_fail;
6119 temp3 = true;
6120 }
6121 }
6122 if (obj3) {
6123 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6124 if (!SWIG_IsOK(res4)) {
6125 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6126 }
6127 arg4 = reinterpret_cast< wxWindow * >(argp4);
6128 }
6129 {
6130 if (!wxPyCheckForApp()) SWIG_fail;
6131 PyThreadState* __tstate = wxPyBeginAllowThreads();
6132 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 {
6137 #if wxUSE_UNICODE
6138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6139 #else
6140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6141 #endif
6142 }
6143 {
6144 if (temp1)
6145 delete arg1;
6146 }
6147 {
6148 if (temp2)
6149 delete arg2;
6150 }
6151 {
6152 if (temp3)
6153 delete arg3;
6154 }
6155 return resultobj;
6156 fail:
6157 {
6158 if (temp1)
6159 delete arg1;
6160 }
6161 {
6162 if (temp2)
6163 delete arg2;
6164 }
6165 {
6166 if (temp3)
6167 delete arg3;
6168 }
6169 return NULL;
6170 }
6171
6172
6173 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6174 PyObject *resultobj = 0;
6175 wxString *arg1 = 0 ;
6176 wxString *arg2 = 0 ;
6177 int arg3 ;
6178 wxString *arg4 = (wxString *) 0 ;
6179 wxWindow *arg5 = (wxWindow *) NULL ;
6180 int arg6 = (int) -1 ;
6181 int arg7 = (int) -1 ;
6182 bool arg8 = (bool) true ;
6183 int arg9 = (int) 150 ;
6184 int arg10 = (int) 200 ;
6185 wxString result;
6186 bool temp1 = false ;
6187 bool temp2 = false ;
6188 void *argp5 = 0 ;
6189 int res5 = 0 ;
6190 int val6 ;
6191 int ecode6 = 0 ;
6192 int val7 ;
6193 int ecode7 = 0 ;
6194 bool val8 ;
6195 int ecode8 = 0 ;
6196 int val9 ;
6197 int ecode9 = 0 ;
6198 int val10 ;
6199 int ecode10 = 0 ;
6200 PyObject * obj0 = 0 ;
6201 PyObject * obj1 = 0 ;
6202 PyObject * obj2 = 0 ;
6203 PyObject * obj3 = 0 ;
6204 PyObject * obj4 = 0 ;
6205 PyObject * obj5 = 0 ;
6206 PyObject * obj6 = 0 ;
6207 PyObject * obj7 = 0 ;
6208 PyObject * obj8 = 0 ;
6209 char * kwnames[] = {
6210 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6211 };
6212
6213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6214 {
6215 arg1 = wxString_in_helper(obj0);
6216 if (arg1 == NULL) SWIG_fail;
6217 temp1 = true;
6218 }
6219 {
6220 arg2 = wxString_in_helper(obj1);
6221 if (arg2 == NULL) SWIG_fail;
6222 temp2 = true;
6223 }
6224 {
6225 arg3 = PyList_Size(obj2);
6226 arg4 = wxString_LIST_helper(obj2);
6227 if (arg4 == NULL) SWIG_fail;
6228 }
6229 if (obj3) {
6230 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6231 if (!SWIG_IsOK(res5)) {
6232 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6233 }
6234 arg5 = reinterpret_cast< wxWindow * >(argp5);
6235 }
6236 if (obj4) {
6237 ecode6 = SWIG_AsVal_int(obj4, &val6);
6238 if (!SWIG_IsOK(ecode6)) {
6239 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6240 }
6241 arg6 = static_cast< int >(val6);
6242 }
6243 if (obj5) {
6244 ecode7 = SWIG_AsVal_int(obj5, &val7);
6245 if (!SWIG_IsOK(ecode7)) {
6246 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6247 }
6248 arg7 = static_cast< int >(val7);
6249 }
6250 if (obj6) {
6251 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6252 if (!SWIG_IsOK(ecode8)) {
6253 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6254 }
6255 arg8 = static_cast< bool >(val8);
6256 }
6257 if (obj7) {
6258 ecode9 = SWIG_AsVal_int(obj7, &val9);
6259 if (!SWIG_IsOK(ecode9)) {
6260 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6261 }
6262 arg9 = static_cast< int >(val9);
6263 }
6264 if (obj8) {
6265 ecode10 = SWIG_AsVal_int(obj8, &val10);
6266 if (!SWIG_IsOK(ecode10)) {
6267 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6268 }
6269 arg10 = static_cast< int >(val10);
6270 }
6271 {
6272 if (!wxPyCheckForApp()) SWIG_fail;
6273 PyThreadState* __tstate = wxPyBeginAllowThreads();
6274 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6275 wxPyEndAllowThreads(__tstate);
6276 if (PyErr_Occurred()) SWIG_fail;
6277 }
6278 {
6279 #if wxUSE_UNICODE
6280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6281 #else
6282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6283 #endif
6284 }
6285 {
6286 if (temp1)
6287 delete arg1;
6288 }
6289 {
6290 if (temp2)
6291 delete arg2;
6292 }
6293 {
6294 if (arg4) delete [] arg4;
6295 }
6296 return resultobj;
6297 fail:
6298 {
6299 if (temp1)
6300 delete arg1;
6301 }
6302 {
6303 if (temp2)
6304 delete arg2;
6305 }
6306 {
6307 if (arg4) delete [] arg4;
6308 }
6309 return NULL;
6310 }
6311
6312
6313 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6314 PyObject *resultobj = 0;
6315 wxString *arg1 = 0 ;
6316 wxString *arg2 = 0 ;
6317 int arg3 ;
6318 wxString *arg4 = (wxString *) 0 ;
6319 wxWindow *arg5 = (wxWindow *) NULL ;
6320 int arg6 = (int) -1 ;
6321 int arg7 = (int) -1 ;
6322 bool arg8 = (bool) true ;
6323 int arg9 = (int) 150 ;
6324 int arg10 = (int) 200 ;
6325 int result;
6326 bool temp1 = false ;
6327 bool temp2 = false ;
6328 void *argp5 = 0 ;
6329 int res5 = 0 ;
6330 int val6 ;
6331 int ecode6 = 0 ;
6332 int val7 ;
6333 int ecode7 = 0 ;
6334 bool val8 ;
6335 int ecode8 = 0 ;
6336 int val9 ;
6337 int ecode9 = 0 ;
6338 int val10 ;
6339 int ecode10 = 0 ;
6340 PyObject * obj0 = 0 ;
6341 PyObject * obj1 = 0 ;
6342 PyObject * obj2 = 0 ;
6343 PyObject * obj3 = 0 ;
6344 PyObject * obj4 = 0 ;
6345 PyObject * obj5 = 0 ;
6346 PyObject * obj6 = 0 ;
6347 PyObject * obj7 = 0 ;
6348 PyObject * obj8 = 0 ;
6349 char * kwnames[] = {
6350 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6351 };
6352
6353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6354 {
6355 arg1 = wxString_in_helper(obj0);
6356 if (arg1 == NULL) SWIG_fail;
6357 temp1 = true;
6358 }
6359 {
6360 arg2 = wxString_in_helper(obj1);
6361 if (arg2 == NULL) SWIG_fail;
6362 temp2 = true;
6363 }
6364 {
6365 arg3 = PyList_Size(obj2);
6366 arg4 = wxString_LIST_helper(obj2);
6367 if (arg4 == NULL) SWIG_fail;
6368 }
6369 if (obj3) {
6370 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6371 if (!SWIG_IsOK(res5)) {
6372 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6373 }
6374 arg5 = reinterpret_cast< wxWindow * >(argp5);
6375 }
6376 if (obj4) {
6377 ecode6 = SWIG_AsVal_int(obj4, &val6);
6378 if (!SWIG_IsOK(ecode6)) {
6379 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6380 }
6381 arg6 = static_cast< int >(val6);
6382 }
6383 if (obj5) {
6384 ecode7 = SWIG_AsVal_int(obj5, &val7);
6385 if (!SWIG_IsOK(ecode7)) {
6386 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6387 }
6388 arg7 = static_cast< int >(val7);
6389 }
6390 if (obj6) {
6391 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6392 if (!SWIG_IsOK(ecode8)) {
6393 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6394 }
6395 arg8 = static_cast< bool >(val8);
6396 }
6397 if (obj7) {
6398 ecode9 = SWIG_AsVal_int(obj7, &val9);
6399 if (!SWIG_IsOK(ecode9)) {
6400 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6401 }
6402 arg9 = static_cast< int >(val9);
6403 }
6404 if (obj8) {
6405 ecode10 = SWIG_AsVal_int(obj8, &val10);
6406 if (!SWIG_IsOK(ecode10)) {
6407 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6408 }
6409 arg10 = static_cast< int >(val10);
6410 }
6411 {
6412 if (!wxPyCheckForApp()) SWIG_fail;
6413 PyThreadState* __tstate = wxPyBeginAllowThreads();
6414 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6415 wxPyEndAllowThreads(__tstate);
6416 if (PyErr_Occurred()) SWIG_fail;
6417 }
6418 resultobj = SWIG_From_int(static_cast< int >(result));
6419 {
6420 if (temp1)
6421 delete arg1;
6422 }
6423 {
6424 if (temp2)
6425 delete arg2;
6426 }
6427 {
6428 if (arg4) delete [] arg4;
6429 }
6430 return resultobj;
6431 fail:
6432 {
6433 if (temp1)
6434 delete arg1;
6435 }
6436 {
6437 if (temp2)
6438 delete arg2;
6439 }
6440 {
6441 if (arg4) delete [] arg4;
6442 }
6443 return NULL;
6444 }
6445
6446
6447 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6448 PyObject *resultobj = 0;
6449 wxString *arg1 = 0 ;
6450 wxString const &arg2_defvalue = wxPyEmptyString ;
6451 wxString *arg2 = (wxString *) &arg2_defvalue ;
6452 int arg3 = (int) wxOK|wxCENTRE ;
6453 wxWindow *arg4 = (wxWindow *) NULL ;
6454 int arg5 = (int) -1 ;
6455 int arg6 = (int) -1 ;
6456 int result;
6457 bool temp1 = false ;
6458 bool temp2 = false ;
6459 int val3 ;
6460 int ecode3 = 0 ;
6461 void *argp4 = 0 ;
6462 int res4 = 0 ;
6463 int val5 ;
6464 int ecode5 = 0 ;
6465 int val6 ;
6466 int ecode6 = 0 ;
6467 PyObject * obj0 = 0 ;
6468 PyObject * obj1 = 0 ;
6469 PyObject * obj2 = 0 ;
6470 PyObject * obj3 = 0 ;
6471 PyObject * obj4 = 0 ;
6472 PyObject * obj5 = 0 ;
6473 char * kwnames[] = {
6474 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6475 };
6476
6477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6478 {
6479 arg1 = wxString_in_helper(obj0);
6480 if (arg1 == NULL) SWIG_fail;
6481 temp1 = true;
6482 }
6483 if (obj1) {
6484 {
6485 arg2 = wxString_in_helper(obj1);
6486 if (arg2 == NULL) SWIG_fail;
6487 temp2 = true;
6488 }
6489 }
6490 if (obj2) {
6491 ecode3 = SWIG_AsVal_int(obj2, &val3);
6492 if (!SWIG_IsOK(ecode3)) {
6493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6494 }
6495 arg3 = static_cast< int >(val3);
6496 }
6497 if (obj3) {
6498 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6499 if (!SWIG_IsOK(res4)) {
6500 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6501 }
6502 arg4 = reinterpret_cast< wxWindow * >(argp4);
6503 }
6504 if (obj4) {
6505 ecode5 = SWIG_AsVal_int(obj4, &val5);
6506 if (!SWIG_IsOK(ecode5)) {
6507 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6508 }
6509 arg5 = static_cast< int >(val5);
6510 }
6511 if (obj5) {
6512 ecode6 = SWIG_AsVal_int(obj5, &val6);
6513 if (!SWIG_IsOK(ecode6)) {
6514 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6515 }
6516 arg6 = static_cast< int >(val6);
6517 }
6518 {
6519 if (!wxPyCheckForApp()) SWIG_fail;
6520 PyThreadState* __tstate = wxPyBeginAllowThreads();
6521 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6522 wxPyEndAllowThreads(__tstate);
6523 if (PyErr_Occurred()) SWIG_fail;
6524 }
6525 resultobj = SWIG_From_int(static_cast< int >(result));
6526 {
6527 if (temp1)
6528 delete arg1;
6529 }
6530 {
6531 if (temp2)
6532 delete arg2;
6533 }
6534 return resultobj;
6535 fail:
6536 {
6537 if (temp1)
6538 delete arg1;
6539 }
6540 {
6541 if (temp2)
6542 delete arg2;
6543 }
6544 return NULL;
6545 }
6546
6547
6548 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6549 PyObject *resultobj = 0;
6550 bool result;
6551
6552 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6553 {
6554 if (!wxPyCheckForApp()) SWIG_fail;
6555 PyThreadState* __tstate = wxPyBeginAllowThreads();
6556 result = (bool)wxColourDisplay();
6557 wxPyEndAllowThreads(__tstate);
6558 if (PyErr_Occurred()) SWIG_fail;
6559 }
6560 {
6561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6562 }
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6570 PyObject *resultobj = 0;
6571 int result;
6572
6573 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6574 {
6575 if (!wxPyCheckForApp()) SWIG_fail;
6576 PyThreadState* __tstate = wxPyBeginAllowThreads();
6577 result = (int)wxDisplayDepth();
6578 wxPyEndAllowThreads(__tstate);
6579 if (PyErr_Occurred()) SWIG_fail;
6580 }
6581 resultobj = SWIG_From_int(static_cast< int >(result));
6582 return resultobj;
6583 fail:
6584 return NULL;
6585 }
6586
6587
6588 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6589 PyObject *resultobj = 0;
6590 int result;
6591
6592 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6593 {
6594 if (!wxPyCheckForApp()) SWIG_fail;
6595 PyThreadState* __tstate = wxPyBeginAllowThreads();
6596 result = (int)wxGetDisplayDepth();
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 resultobj = SWIG_From_int(static_cast< int >(result));
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6608 PyObject *resultobj = 0;
6609 int *arg1 = (int *) 0 ;
6610 int *arg2 = (int *) 0 ;
6611 int temp1 ;
6612 int res1 = SWIG_TMPOBJ ;
6613 int temp2 ;
6614 int res2 = SWIG_TMPOBJ ;
6615
6616 arg1 = &temp1;
6617 arg2 = &temp2;
6618 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6619 {
6620 if (!wxPyCheckForApp()) SWIG_fail;
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 wxDisplaySize(arg1,arg2);
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_Py_Void();
6627 if (SWIG_IsTmpObj(res1)) {
6628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6629 } else {
6630 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6632 }
6633 if (SWIG_IsTmpObj(res2)) {
6634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6635 } else {
6636 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6638 }
6639 return resultobj;
6640 fail:
6641 return NULL;
6642 }
6643
6644
6645 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6646 PyObject *resultobj = 0;
6647 wxSize result;
6648
6649 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6650 {
6651 if (!wxPyCheckForApp()) SWIG_fail;
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 result = wxGetDisplaySize();
6654 wxPyEndAllowThreads(__tstate);
6655 if (PyErr_Occurred()) SWIG_fail;
6656 }
6657 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6658 return resultobj;
6659 fail:
6660 return NULL;
6661 }
6662
6663
6664 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6665 PyObject *resultobj = 0;
6666 int *arg1 = (int *) 0 ;
6667 int *arg2 = (int *) 0 ;
6668 int temp1 ;
6669 int res1 = SWIG_TMPOBJ ;
6670 int temp2 ;
6671 int res2 = SWIG_TMPOBJ ;
6672
6673 arg1 = &temp1;
6674 arg2 = &temp2;
6675 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6676 {
6677 if (!wxPyCheckForApp()) SWIG_fail;
6678 PyThreadState* __tstate = wxPyBeginAllowThreads();
6679 wxDisplaySizeMM(arg1,arg2);
6680 wxPyEndAllowThreads(__tstate);
6681 if (PyErr_Occurred()) SWIG_fail;
6682 }
6683 resultobj = SWIG_Py_Void();
6684 if (SWIG_IsTmpObj(res1)) {
6685 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6686 } else {
6687 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6689 }
6690 if (SWIG_IsTmpObj(res2)) {
6691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6692 } else {
6693 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6695 }
6696 return resultobj;
6697 fail:
6698 return NULL;
6699 }
6700
6701
6702 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6703 PyObject *resultobj = 0;
6704 wxSize result;
6705
6706 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6707 {
6708 if (!wxPyCheckForApp()) SWIG_fail;
6709 PyThreadState* __tstate = wxPyBeginAllowThreads();
6710 result = wxGetDisplaySizeMM();
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6722 PyObject *resultobj = 0;
6723 int *arg1 = (int *) 0 ;
6724 int *arg2 = (int *) 0 ;
6725 int *arg3 = (int *) 0 ;
6726 int *arg4 = (int *) 0 ;
6727 int temp1 ;
6728 int res1 = SWIG_TMPOBJ ;
6729 int temp2 ;
6730 int res2 = SWIG_TMPOBJ ;
6731 int temp3 ;
6732 int res3 = SWIG_TMPOBJ ;
6733 int temp4 ;
6734 int res4 = SWIG_TMPOBJ ;
6735
6736 arg1 = &temp1;
6737 arg2 = &temp2;
6738 arg3 = &temp3;
6739 arg4 = &temp4;
6740 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6741 {
6742 if (!wxPyCheckForApp()) SWIG_fail;
6743 PyThreadState* __tstate = wxPyBeginAllowThreads();
6744 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6745 wxPyEndAllowThreads(__tstate);
6746 if (PyErr_Occurred()) SWIG_fail;
6747 }
6748 resultobj = SWIG_Py_Void();
6749 if (SWIG_IsTmpObj(res1)) {
6750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6751 } else {
6752 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6754 }
6755 if (SWIG_IsTmpObj(res2)) {
6756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6757 } else {
6758 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6760 }
6761 if (SWIG_IsTmpObj(res3)) {
6762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6763 } else {
6764 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6766 }
6767 if (SWIG_IsTmpObj(res4)) {
6768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6769 } else {
6770 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6772 }
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6780 PyObject *resultobj = 0;
6781 wxRect result;
6782
6783 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6784 {
6785 if (!wxPyCheckForApp()) SWIG_fail;
6786 PyThreadState* __tstate = wxPyBeginAllowThreads();
6787 result = wxGetClientDisplayRect();
6788 wxPyEndAllowThreads(__tstate);
6789 if (PyErr_Occurred()) SWIG_fail;
6790 }
6791 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6792 return resultobj;
6793 fail:
6794 return NULL;
6795 }
6796
6797
6798 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6799 PyObject *resultobj = 0;
6800 wxCursor *arg1 = 0 ;
6801 void *argp1 = 0 ;
6802 int res1 = 0 ;
6803 PyObject * obj0 = 0 ;
6804 char * kwnames[] = {
6805 (char *) "cursor", NULL
6806 };
6807
6808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6809 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6810 if (!SWIG_IsOK(res1)) {
6811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6812 }
6813 if (!argp1) {
6814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6815 }
6816 arg1 = reinterpret_cast< wxCursor * >(argp1);
6817 {
6818 if (!wxPyCheckForApp()) SWIG_fail;
6819 PyThreadState* __tstate = wxPyBeginAllowThreads();
6820 wxSetCursor(*arg1);
6821 wxPyEndAllowThreads(__tstate);
6822 if (PyErr_Occurred()) SWIG_fail;
6823 }
6824 resultobj = SWIG_Py_Void();
6825 return resultobj;
6826 fail:
6827 return NULL;
6828 }
6829
6830
6831 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6832 PyObject *resultobj = 0;
6833 void *result = 0 ;
6834
6835 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6836 {
6837 if (!wxPyCheckForApp()) SWIG_fail;
6838 PyThreadState* __tstate = wxPyBeginAllowThreads();
6839 result = (void *)wxGetXDisplay();
6840 wxPyEndAllowThreads(__tstate);
6841 if (PyErr_Occurred()) SWIG_fail;
6842 }
6843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6844 return resultobj;
6845 fail:
6846 return NULL;
6847 }
6848
6849
6850 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6851 PyObject *resultobj = 0;
6852 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6853 void *argp1 = 0 ;
6854 int res1 = 0 ;
6855 PyObject * obj0 = 0 ;
6856 char * kwnames[] = {
6857 (char *) "cursor", NULL
6858 };
6859
6860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6861 if (obj0) {
6862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6863 if (!SWIG_IsOK(res1)) {
6864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6865 }
6866 arg1 = reinterpret_cast< wxCursor * >(argp1);
6867 }
6868 {
6869 if (!wxPyCheckForApp()) SWIG_fail;
6870 PyThreadState* __tstate = wxPyBeginAllowThreads();
6871 wxBeginBusyCursor(arg1);
6872 wxPyEndAllowThreads(__tstate);
6873 if (PyErr_Occurred()) SWIG_fail;
6874 }
6875 resultobj = SWIG_Py_Void();
6876 return resultobj;
6877 fail:
6878 return NULL;
6879 }
6880
6881
6882 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6883 PyObject *resultobj = 0;
6884 wxPoint result;
6885
6886 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6887 {
6888 if (!wxPyCheckForApp()) SWIG_fail;
6889 PyThreadState* __tstate = wxPyBeginAllowThreads();
6890 result = wxGetMousePosition();
6891 wxPyEndAllowThreads(__tstate);
6892 if (PyErr_Occurred()) SWIG_fail;
6893 }
6894 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6895 return resultobj;
6896 fail:
6897 return NULL;
6898 }
6899
6900
6901 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6902 PyObject *resultobj = 0;
6903 wxWindow *result = 0 ;
6904
6905 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6906 {
6907 if (!wxPyCheckForApp()) SWIG_fail;
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 result = (wxWindow *)FindWindowAtPointer();
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 {
6914 resultobj = wxPyMake_wxObject(result, 0);
6915 }
6916 return resultobj;
6917 fail:
6918 return NULL;
6919 }
6920
6921
6922 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6923 PyObject *resultobj = 0;
6924 wxWindow *result = 0 ;
6925
6926 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6927 {
6928 if (!wxPyCheckForApp()) SWIG_fail;
6929 PyThreadState* __tstate = wxPyBeginAllowThreads();
6930 result = (wxWindow *)wxGetActiveWindow();
6931 wxPyEndAllowThreads(__tstate);
6932 if (PyErr_Occurred()) SWIG_fail;
6933 }
6934 {
6935 resultobj = wxPyMake_wxObject(result, 0);
6936 }
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6944 PyObject *resultobj = 0;
6945 wxPoint *arg1 = 0 ;
6946 wxWindow *result = 0 ;
6947 wxPoint temp1 ;
6948 PyObject * obj0 = 0 ;
6949 char * kwnames[] = {
6950 (char *) "pt", NULL
6951 };
6952
6953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6954 {
6955 arg1 = &temp1;
6956 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6957 }
6958 {
6959 if (!wxPyCheckForApp()) SWIG_fail;
6960 PyThreadState* __tstate = wxPyBeginAllowThreads();
6961 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 {
6966 resultobj = wxPyMake_wxObject(result, 0);
6967 }
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6975 PyObject *resultobj = 0;
6976 wxPoint *arg1 = 0 ;
6977 wxWindow *result = 0 ;
6978 wxPoint temp1 ;
6979 PyObject * obj0 = 0 ;
6980 char * kwnames[] = {
6981 (char *) "pt", NULL
6982 };
6983
6984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6985 {
6986 arg1 = &temp1;
6987 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6988 }
6989 {
6990 if (!wxPyCheckForApp()) SWIG_fail;
6991 PyThreadState* __tstate = wxPyBeginAllowThreads();
6992 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6993 wxPyEndAllowThreads(__tstate);
6994 if (PyErr_Occurred()) SWIG_fail;
6995 }
6996 {
6997 resultobj = wxPyMake_wxObject(result, 0);
6998 }
6999 return resultobj;
7000 fail:
7001 return NULL;
7002 }
7003
7004
7005 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7006 PyObject *resultobj = 0;
7007 wxWindow *arg1 = (wxWindow *) 0 ;
7008 wxWindow *result = 0 ;
7009 void *argp1 = 0 ;
7010 int res1 = 0 ;
7011 PyObject * obj0 = 0 ;
7012 char * kwnames[] = {
7013 (char *) "win", NULL
7014 };
7015
7016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7018 if (!SWIG_IsOK(res1)) {
7019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7020 }
7021 arg1 = reinterpret_cast< wxWindow * >(argp1);
7022 {
7023 if (!wxPyCheckForApp()) SWIG_fail;
7024 PyThreadState* __tstate = wxPyBeginAllowThreads();
7025 result = (wxWindow *)wxGetTopLevelParent(arg1);
7026 wxPyEndAllowThreads(__tstate);
7027 if (PyErr_Occurred()) SWIG_fail;
7028 }
7029 {
7030 resultobj = wxPyMake_wxObject(result, 0);
7031 }
7032 return resultobj;
7033 fail:
7034 return NULL;
7035 }
7036
7037
7038 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7039 PyObject *resultobj = 0;
7040 wxString *arg1 = 0 ;
7041 bool result;
7042 bool temp1 = false ;
7043 PyObject * obj0 = 0 ;
7044 char * kwnames[] = {
7045 (char *) "url", NULL
7046 };
7047
7048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7049 {
7050 arg1 = wxString_in_helper(obj0);
7051 if (arg1 == NULL) SWIG_fail;
7052 temp1 = true;
7053 }
7054 {
7055 PyThreadState* __tstate = wxPyBeginAllowThreads();
7056 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7057 wxPyEndAllowThreads(__tstate);
7058 if (PyErr_Occurred()) SWIG_fail;
7059 }
7060 {
7061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7062 }
7063 {
7064 if (temp1)
7065 delete arg1;
7066 }
7067 return resultobj;
7068 fail:
7069 {
7070 if (temp1)
7071 delete arg1;
7072 }
7073 return NULL;
7074 }
7075
7076
7077 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7078 PyObject *resultobj = 0;
7079 wxKeyCode arg1 ;
7080 bool result;
7081 int val1 ;
7082 int ecode1 = 0 ;
7083 PyObject * obj0 = 0 ;
7084 char * kwnames[] = {
7085 (char *) "key", NULL
7086 };
7087
7088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7089 ecode1 = SWIG_AsVal_int(obj0, &val1);
7090 if (!SWIG_IsOK(ecode1)) {
7091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7092 }
7093 arg1 = static_cast< wxKeyCode >(val1);
7094 {
7095 if (!wxPyCheckForApp()) SWIG_fail;
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 result = (bool)wxGetKeyState(arg1);
7098 wxPyEndAllowThreads(__tstate);
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 {
7102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7103 }
7104 return resultobj;
7105 fail:
7106 return NULL;
7107 }
7108
7109
7110 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7111 PyObject *resultobj = 0;
7112 wxMouseState *result = 0 ;
7113
7114 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7115 {
7116 PyThreadState* __tstate = wxPyBeginAllowThreads();
7117 result = (wxMouseState *)new wxMouseState();
7118 wxPyEndAllowThreads(__tstate);
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7129 PyObject *resultobj = 0;
7130 wxMouseState *arg1 = (wxMouseState *) 0 ;
7131 void *argp1 = 0 ;
7132 int res1 = 0 ;
7133 PyObject *swig_obj[1] ;
7134
7135 if (!args) SWIG_fail;
7136 swig_obj[0] = args;
7137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7138 if (!SWIG_IsOK(res1)) {
7139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7140 }
7141 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7142 {
7143 PyThreadState* __tstate = wxPyBeginAllowThreads();
7144 delete arg1;
7145
7146 wxPyEndAllowThreads(__tstate);
7147 if (PyErr_Occurred()) SWIG_fail;
7148 }
7149 resultobj = SWIG_Py_Void();
7150 return resultobj;
7151 fail:
7152 return NULL;
7153 }
7154
7155
7156 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7157 PyObject *resultobj = 0;
7158 wxMouseState *arg1 = (wxMouseState *) 0 ;
7159 int result;
7160 void *argp1 = 0 ;
7161 int res1 = 0 ;
7162 PyObject *swig_obj[1] ;
7163
7164 if (!args) SWIG_fail;
7165 swig_obj[0] = args;
7166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7167 if (!SWIG_IsOK(res1)) {
7168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7169 }
7170 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7171 {
7172 PyThreadState* __tstate = wxPyBeginAllowThreads();
7173 result = (int)(arg1)->GetX();
7174 wxPyEndAllowThreads(__tstate);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 resultobj = SWIG_From_int(static_cast< int >(result));
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7185 PyObject *resultobj = 0;
7186 wxMouseState *arg1 = (wxMouseState *) 0 ;
7187 int result;
7188 void *argp1 = 0 ;
7189 int res1 = 0 ;
7190 PyObject *swig_obj[1] ;
7191
7192 if (!args) SWIG_fail;
7193 swig_obj[0] = args;
7194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7195 if (!SWIG_IsOK(res1)) {
7196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7197 }
7198 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7199 {
7200 PyThreadState* __tstate = wxPyBeginAllowThreads();
7201 result = (int)(arg1)->GetY();
7202 wxPyEndAllowThreads(__tstate);
7203 if (PyErr_Occurred()) SWIG_fail;
7204 }
7205 resultobj = SWIG_From_int(static_cast< int >(result));
7206 return resultobj;
7207 fail:
7208 return NULL;
7209 }
7210
7211
7212 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7213 PyObject *resultobj = 0;
7214 wxMouseState *arg1 = (wxMouseState *) 0 ;
7215 bool result;
7216 void *argp1 = 0 ;
7217 int res1 = 0 ;
7218 PyObject *swig_obj[1] ;
7219
7220 if (!args) SWIG_fail;
7221 swig_obj[0] = args;
7222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7223 if (!SWIG_IsOK(res1)) {
7224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7225 }
7226 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 result = (bool)(arg1)->LeftDown();
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 {
7234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7235 }
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7243 PyObject *resultobj = 0;
7244 wxMouseState *arg1 = (wxMouseState *) 0 ;
7245 bool result;
7246 void *argp1 = 0 ;
7247 int res1 = 0 ;
7248 PyObject *swig_obj[1] ;
7249
7250 if (!args) SWIG_fail;
7251 swig_obj[0] = args;
7252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7253 if (!SWIG_IsOK(res1)) {
7254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7255 }
7256 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7257 {
7258 PyThreadState* __tstate = wxPyBeginAllowThreads();
7259 result = (bool)(arg1)->MiddleDown();
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 {
7264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7265 }
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7273 PyObject *resultobj = 0;
7274 wxMouseState *arg1 = (wxMouseState *) 0 ;
7275 bool result;
7276 void *argp1 = 0 ;
7277 int res1 = 0 ;
7278 PyObject *swig_obj[1] ;
7279
7280 if (!args) SWIG_fail;
7281 swig_obj[0] = args;
7282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7283 if (!SWIG_IsOK(res1)) {
7284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7285 }
7286 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7287 {
7288 PyThreadState* __tstate = wxPyBeginAllowThreads();
7289 result = (bool)(arg1)->RightDown();
7290 wxPyEndAllowThreads(__tstate);
7291 if (PyErr_Occurred()) SWIG_fail;
7292 }
7293 {
7294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7295 }
7296 return resultobj;
7297 fail:
7298 return NULL;
7299 }
7300
7301
7302 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7303 PyObject *resultobj = 0;
7304 wxMouseState *arg1 = (wxMouseState *) 0 ;
7305 bool result;
7306 void *argp1 = 0 ;
7307 int res1 = 0 ;
7308 PyObject *swig_obj[1] ;
7309
7310 if (!args) SWIG_fail;
7311 swig_obj[0] = args;
7312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7313 if (!SWIG_IsOK(res1)) {
7314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7315 }
7316 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7317 {
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 result = (bool)(arg1)->ControlDown();
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 {
7324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7325 }
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7333 PyObject *resultobj = 0;
7334 wxMouseState *arg1 = (wxMouseState *) 0 ;
7335 bool result;
7336 void *argp1 = 0 ;
7337 int res1 = 0 ;
7338 PyObject *swig_obj[1] ;
7339
7340 if (!args) SWIG_fail;
7341 swig_obj[0] = args;
7342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7343 if (!SWIG_IsOK(res1)) {
7344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7345 }
7346 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7347 {
7348 PyThreadState* __tstate = wxPyBeginAllowThreads();
7349 result = (bool)(arg1)->ShiftDown();
7350 wxPyEndAllowThreads(__tstate);
7351 if (PyErr_Occurred()) SWIG_fail;
7352 }
7353 {
7354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7355 }
7356 return resultobj;
7357 fail:
7358 return NULL;
7359 }
7360
7361
7362 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7363 PyObject *resultobj = 0;
7364 wxMouseState *arg1 = (wxMouseState *) 0 ;
7365 bool result;
7366 void *argp1 = 0 ;
7367 int res1 = 0 ;
7368 PyObject *swig_obj[1] ;
7369
7370 if (!args) SWIG_fail;
7371 swig_obj[0] = args;
7372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7373 if (!SWIG_IsOK(res1)) {
7374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7375 }
7376 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7377 {
7378 PyThreadState* __tstate = wxPyBeginAllowThreads();
7379 result = (bool)(arg1)->AltDown();
7380 wxPyEndAllowThreads(__tstate);
7381 if (PyErr_Occurred()) SWIG_fail;
7382 }
7383 {
7384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7385 }
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7393 PyObject *resultobj = 0;
7394 wxMouseState *arg1 = (wxMouseState *) 0 ;
7395 bool result;
7396 void *argp1 = 0 ;
7397 int res1 = 0 ;
7398 PyObject *swig_obj[1] ;
7399
7400 if (!args) SWIG_fail;
7401 swig_obj[0] = args;
7402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7403 if (!SWIG_IsOK(res1)) {
7404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7405 }
7406 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7407 {
7408 PyThreadState* __tstate = wxPyBeginAllowThreads();
7409 result = (bool)(arg1)->MetaDown();
7410 wxPyEndAllowThreads(__tstate);
7411 if (PyErr_Occurred()) SWIG_fail;
7412 }
7413 {
7414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7415 }
7416 return resultobj;
7417 fail:
7418 return NULL;
7419 }
7420
7421
7422 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7423 PyObject *resultobj = 0;
7424 wxMouseState *arg1 = (wxMouseState *) 0 ;
7425 bool result;
7426 void *argp1 = 0 ;
7427 int res1 = 0 ;
7428 PyObject *swig_obj[1] ;
7429
7430 if (!args) SWIG_fail;
7431 swig_obj[0] = args;
7432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7433 if (!SWIG_IsOK(res1)) {
7434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7435 }
7436 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 result = (bool)(arg1)->CmdDown();
7440 wxPyEndAllowThreads(__tstate);
7441 if (PyErr_Occurred()) SWIG_fail;
7442 }
7443 {
7444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7445 }
7446 return resultobj;
7447 fail:
7448 return NULL;
7449 }
7450
7451
7452 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7453 PyObject *resultobj = 0;
7454 wxMouseState *arg1 = (wxMouseState *) 0 ;
7455 int arg2 ;
7456 void *argp1 = 0 ;
7457 int res1 = 0 ;
7458 int val2 ;
7459 int ecode2 = 0 ;
7460 PyObject * obj0 = 0 ;
7461 PyObject * obj1 = 0 ;
7462 char * kwnames[] = {
7463 (char *) "self",(char *) "x", NULL
7464 };
7465
7466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7468 if (!SWIG_IsOK(res1)) {
7469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7470 }
7471 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7472 ecode2 = SWIG_AsVal_int(obj1, &val2);
7473 if (!SWIG_IsOK(ecode2)) {
7474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7475 }
7476 arg2 = static_cast< int >(val2);
7477 {
7478 PyThreadState* __tstate = wxPyBeginAllowThreads();
7479 (arg1)->SetX(arg2);
7480 wxPyEndAllowThreads(__tstate);
7481 if (PyErr_Occurred()) SWIG_fail;
7482 }
7483 resultobj = SWIG_Py_Void();
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7491 PyObject *resultobj = 0;
7492 wxMouseState *arg1 = (wxMouseState *) 0 ;
7493 int arg2 ;
7494 void *argp1 = 0 ;
7495 int res1 = 0 ;
7496 int val2 ;
7497 int ecode2 = 0 ;
7498 PyObject * obj0 = 0 ;
7499 PyObject * obj1 = 0 ;
7500 char * kwnames[] = {
7501 (char *) "self",(char *) "y", NULL
7502 };
7503
7504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7506 if (!SWIG_IsOK(res1)) {
7507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7508 }
7509 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7510 ecode2 = SWIG_AsVal_int(obj1, &val2);
7511 if (!SWIG_IsOK(ecode2)) {
7512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7513 }
7514 arg2 = static_cast< int >(val2);
7515 {
7516 PyThreadState* __tstate = wxPyBeginAllowThreads();
7517 (arg1)->SetY(arg2);
7518 wxPyEndAllowThreads(__tstate);
7519 if (PyErr_Occurred()) SWIG_fail;
7520 }
7521 resultobj = SWIG_Py_Void();
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj = 0;
7530 wxMouseState *arg1 = (wxMouseState *) 0 ;
7531 bool arg2 ;
7532 void *argp1 = 0 ;
7533 int res1 = 0 ;
7534 bool val2 ;
7535 int ecode2 = 0 ;
7536 PyObject * obj0 = 0 ;
7537 PyObject * obj1 = 0 ;
7538 char * kwnames[] = {
7539 (char *) "self",(char *) "down", NULL
7540 };
7541
7542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7544 if (!SWIG_IsOK(res1)) {
7545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7546 }
7547 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7548 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7549 if (!SWIG_IsOK(ecode2)) {
7550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7551 }
7552 arg2 = static_cast< bool >(val2);
7553 {
7554 PyThreadState* __tstate = wxPyBeginAllowThreads();
7555 (arg1)->SetLeftDown(arg2);
7556 wxPyEndAllowThreads(__tstate);
7557 if (PyErr_Occurred()) SWIG_fail;
7558 }
7559 resultobj = SWIG_Py_Void();
7560 return resultobj;
7561 fail:
7562 return NULL;
7563 }
7564
7565
7566 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7567 PyObject *resultobj = 0;
7568 wxMouseState *arg1 = (wxMouseState *) 0 ;
7569 bool arg2 ;
7570 void *argp1 = 0 ;
7571 int res1 = 0 ;
7572 bool val2 ;
7573 int ecode2 = 0 ;
7574 PyObject * obj0 = 0 ;
7575 PyObject * obj1 = 0 ;
7576 char * kwnames[] = {
7577 (char *) "self",(char *) "down", NULL
7578 };
7579
7580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7582 if (!SWIG_IsOK(res1)) {
7583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7584 }
7585 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7586 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7587 if (!SWIG_IsOK(ecode2)) {
7588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7589 }
7590 arg2 = static_cast< bool >(val2);
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 (arg1)->SetMiddleDown(arg2);
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 resultobj = SWIG_Py_Void();
7598 return resultobj;
7599 fail:
7600 return NULL;
7601 }
7602
7603
7604 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7605 PyObject *resultobj = 0;
7606 wxMouseState *arg1 = (wxMouseState *) 0 ;
7607 bool arg2 ;
7608 void *argp1 = 0 ;
7609 int res1 = 0 ;
7610 bool val2 ;
7611 int ecode2 = 0 ;
7612 PyObject * obj0 = 0 ;
7613 PyObject * obj1 = 0 ;
7614 char * kwnames[] = {
7615 (char *) "self",(char *) "down", NULL
7616 };
7617
7618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7620 if (!SWIG_IsOK(res1)) {
7621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7622 }
7623 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7624 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7625 if (!SWIG_IsOK(ecode2)) {
7626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7627 }
7628 arg2 = static_cast< bool >(val2);
7629 {
7630 PyThreadState* __tstate = wxPyBeginAllowThreads();
7631 (arg1)->SetRightDown(arg2);
7632 wxPyEndAllowThreads(__tstate);
7633 if (PyErr_Occurred()) SWIG_fail;
7634 }
7635 resultobj = SWIG_Py_Void();
7636 return resultobj;
7637 fail:
7638 return NULL;
7639 }
7640
7641
7642 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7643 PyObject *resultobj = 0;
7644 wxMouseState *arg1 = (wxMouseState *) 0 ;
7645 bool arg2 ;
7646 void *argp1 = 0 ;
7647 int res1 = 0 ;
7648 bool val2 ;
7649 int ecode2 = 0 ;
7650 PyObject * obj0 = 0 ;
7651 PyObject * obj1 = 0 ;
7652 char * kwnames[] = {
7653 (char *) "self",(char *) "down", NULL
7654 };
7655
7656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7658 if (!SWIG_IsOK(res1)) {
7659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7660 }
7661 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7662 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7663 if (!SWIG_IsOK(ecode2)) {
7664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7665 }
7666 arg2 = static_cast< bool >(val2);
7667 {
7668 PyThreadState* __tstate = wxPyBeginAllowThreads();
7669 (arg1)->SetControlDown(arg2);
7670 wxPyEndAllowThreads(__tstate);
7671 if (PyErr_Occurred()) SWIG_fail;
7672 }
7673 resultobj = SWIG_Py_Void();
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7681 PyObject *resultobj = 0;
7682 wxMouseState *arg1 = (wxMouseState *) 0 ;
7683 bool arg2 ;
7684 void *argp1 = 0 ;
7685 int res1 = 0 ;
7686 bool val2 ;
7687 int ecode2 = 0 ;
7688 PyObject * obj0 = 0 ;
7689 PyObject * obj1 = 0 ;
7690 char * kwnames[] = {
7691 (char *) "self",(char *) "down", NULL
7692 };
7693
7694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7696 if (!SWIG_IsOK(res1)) {
7697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7698 }
7699 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7700 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7701 if (!SWIG_IsOK(ecode2)) {
7702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7703 }
7704 arg2 = static_cast< bool >(val2);
7705 {
7706 PyThreadState* __tstate = wxPyBeginAllowThreads();
7707 (arg1)->SetShiftDown(arg2);
7708 wxPyEndAllowThreads(__tstate);
7709 if (PyErr_Occurred()) SWIG_fail;
7710 }
7711 resultobj = SWIG_Py_Void();
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj = 0;
7720 wxMouseState *arg1 = (wxMouseState *) 0 ;
7721 bool arg2 ;
7722 void *argp1 = 0 ;
7723 int res1 = 0 ;
7724 bool val2 ;
7725 int ecode2 = 0 ;
7726 PyObject * obj0 = 0 ;
7727 PyObject * obj1 = 0 ;
7728 char * kwnames[] = {
7729 (char *) "self",(char *) "down", NULL
7730 };
7731
7732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7734 if (!SWIG_IsOK(res1)) {
7735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7736 }
7737 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7738 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7739 if (!SWIG_IsOK(ecode2)) {
7740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7741 }
7742 arg2 = static_cast< bool >(val2);
7743 {
7744 PyThreadState* __tstate = wxPyBeginAllowThreads();
7745 (arg1)->SetAltDown(arg2);
7746 wxPyEndAllowThreads(__tstate);
7747 if (PyErr_Occurred()) SWIG_fail;
7748 }
7749 resultobj = SWIG_Py_Void();
7750 return resultobj;
7751 fail:
7752 return NULL;
7753 }
7754
7755
7756 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7757 PyObject *resultobj = 0;
7758 wxMouseState *arg1 = (wxMouseState *) 0 ;
7759 bool arg2 ;
7760 void *argp1 = 0 ;
7761 int res1 = 0 ;
7762 bool val2 ;
7763 int ecode2 = 0 ;
7764 PyObject * obj0 = 0 ;
7765 PyObject * obj1 = 0 ;
7766 char * kwnames[] = {
7767 (char *) "self",(char *) "down", NULL
7768 };
7769
7770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7772 if (!SWIG_IsOK(res1)) {
7773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7774 }
7775 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7776 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7777 if (!SWIG_IsOK(ecode2)) {
7778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7779 }
7780 arg2 = static_cast< bool >(val2);
7781 {
7782 PyThreadState* __tstate = wxPyBeginAllowThreads();
7783 (arg1)->SetMetaDown(arg2);
7784 wxPyEndAllowThreads(__tstate);
7785 if (PyErr_Occurred()) SWIG_fail;
7786 }
7787 resultobj = SWIG_Py_Void();
7788 return resultobj;
7789 fail:
7790 return NULL;
7791 }
7792
7793
7794 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7795 PyObject *obj;
7796 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7797 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7798 return SWIG_Py_Void();
7799 }
7800
7801 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7802 return SWIG_Python_InitShadowInstance(args);
7803 }
7804
7805 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7806 PyObject *resultobj = 0;
7807 wxMouseState result;
7808
7809 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7810 {
7811 PyThreadState* __tstate = wxPyBeginAllowThreads();
7812 result = wxGetMouseState();
7813 wxPyEndAllowThreads(__tstate);
7814 if (PyErr_Occurred()) SWIG_fail;
7815 }
7816 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7817 return resultobj;
7818 fail:
7819 return NULL;
7820 }
7821
7822
7823 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7824 PyObject *resultobj = 0;
7825
7826 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7827 {
7828 if (!wxPyCheckForApp()) SWIG_fail;
7829 PyThreadState* __tstate = wxPyBeginAllowThreads();
7830 wxWakeUpMainThread();
7831 wxPyEndAllowThreads(__tstate);
7832 if (PyErr_Occurred()) SWIG_fail;
7833 }
7834 resultobj = SWIG_Py_Void();
7835 return resultobj;
7836 fail:
7837 return NULL;
7838 }
7839
7840
7841 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7842 PyObject *resultobj = 0;
7843
7844 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7845 {
7846 if (!wxPyCheckForApp()) SWIG_fail;
7847 PyThreadState* __tstate = wxPyBeginAllowThreads();
7848 wxMutexGuiEnter();
7849 wxPyEndAllowThreads(__tstate);
7850 if (PyErr_Occurred()) SWIG_fail;
7851 }
7852 resultobj = SWIG_Py_Void();
7853 return resultobj;
7854 fail:
7855 return NULL;
7856 }
7857
7858
7859 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7860 PyObject *resultobj = 0;
7861
7862 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7863 {
7864 if (!wxPyCheckForApp()) SWIG_fail;
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 wxMutexGuiLeave();
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 resultobj = SWIG_Py_Void();
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7878 PyObject *resultobj = 0;
7879 wxMutexGuiLocker *result = 0 ;
7880
7881 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7882 {
7883 if (!wxPyCheckForApp()) SWIG_fail;
7884 PyThreadState* __tstate = wxPyBeginAllowThreads();
7885 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7897 PyObject *resultobj = 0;
7898 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7899 void *argp1 = 0 ;
7900 int res1 = 0 ;
7901 PyObject *swig_obj[1] ;
7902
7903 if (!args) SWIG_fail;
7904 swig_obj[0] = args;
7905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7906 if (!SWIG_IsOK(res1)) {
7907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7908 }
7909 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7910 {
7911 PyThreadState* __tstate = wxPyBeginAllowThreads();
7912 delete arg1;
7913
7914 wxPyEndAllowThreads(__tstate);
7915 if (PyErr_Occurred()) SWIG_fail;
7916 }
7917 resultobj = SWIG_Py_Void();
7918 return resultobj;
7919 fail:
7920 return NULL;
7921 }
7922
7923
7924 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7925 PyObject *obj;
7926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7927 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7928 return SWIG_Py_Void();
7929 }
7930
7931 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7932 return SWIG_Python_InitShadowInstance(args);
7933 }
7934
7935 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7936 PyObject *resultobj = 0;
7937 bool result;
7938
7939 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7940 {
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 result = (bool)wxThread_IsMain();
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 {
7947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7948 }
7949 return resultobj;
7950 fail:
7951 return NULL;
7952 }
7953
7954
7955 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7956 PyObject *resultobj = 0;
7957 wxString *arg1 = 0 ;
7958 wxToolTip *result = 0 ;
7959 bool temp1 = false ;
7960 PyObject * obj0 = 0 ;
7961 char * kwnames[] = {
7962 (char *) "tip", NULL
7963 };
7964
7965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7966 {
7967 arg1 = wxString_in_helper(obj0);
7968 if (arg1 == NULL) SWIG_fail;
7969 temp1 = true;
7970 }
7971 {
7972 if (!wxPyCheckForApp()) SWIG_fail;
7973 PyThreadState* __tstate = wxPyBeginAllowThreads();
7974 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7975 wxPyEndAllowThreads(__tstate);
7976 if (PyErr_Occurred()) SWIG_fail;
7977 }
7978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7979 {
7980 if (temp1)
7981 delete arg1;
7982 }
7983 return resultobj;
7984 fail:
7985 {
7986 if (temp1)
7987 delete arg1;
7988 }
7989 return NULL;
7990 }
7991
7992
7993 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7994 PyObject *resultobj = 0;
7995 wxToolTip *arg1 = (wxToolTip *) 0 ;
7996 void *argp1 = 0 ;
7997 int res1 = 0 ;
7998 PyObject *swig_obj[1] ;
7999
8000 if (!args) SWIG_fail;
8001 swig_obj[0] = args;
8002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8003 if (!SWIG_IsOK(res1)) {
8004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8005 }
8006 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8007 {
8008 PyThreadState* __tstate = wxPyBeginAllowThreads();
8009 delete arg1;
8010
8011 wxPyEndAllowThreads(__tstate);
8012 if (PyErr_Occurred()) SWIG_fail;
8013 }
8014 resultobj = SWIG_Py_Void();
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8022 PyObject *resultobj = 0;
8023 wxToolTip *arg1 = (wxToolTip *) 0 ;
8024 wxString *arg2 = 0 ;
8025 void *argp1 = 0 ;
8026 int res1 = 0 ;
8027 bool temp2 = false ;
8028 PyObject * obj0 = 0 ;
8029 PyObject * obj1 = 0 ;
8030 char * kwnames[] = {
8031 (char *) "self",(char *) "tip", NULL
8032 };
8033
8034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8036 if (!SWIG_IsOK(res1)) {
8037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8038 }
8039 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8040 {
8041 arg2 = wxString_in_helper(obj1);
8042 if (arg2 == NULL) SWIG_fail;
8043 temp2 = true;
8044 }
8045 {
8046 PyThreadState* __tstate = wxPyBeginAllowThreads();
8047 (arg1)->SetTip((wxString const &)*arg2);
8048 wxPyEndAllowThreads(__tstate);
8049 if (PyErr_Occurred()) SWIG_fail;
8050 }
8051 resultobj = SWIG_Py_Void();
8052 {
8053 if (temp2)
8054 delete arg2;
8055 }
8056 return resultobj;
8057 fail:
8058 {
8059 if (temp2)
8060 delete arg2;
8061 }
8062 return NULL;
8063 }
8064
8065
8066 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8067 PyObject *resultobj = 0;
8068 wxToolTip *arg1 = (wxToolTip *) 0 ;
8069 wxString result;
8070 void *argp1 = 0 ;
8071 int res1 = 0 ;
8072 PyObject *swig_obj[1] ;
8073
8074 if (!args) SWIG_fail;
8075 swig_obj[0] = args;
8076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8077 if (!SWIG_IsOK(res1)) {
8078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8079 }
8080 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8081 {
8082 PyThreadState* __tstate = wxPyBeginAllowThreads();
8083 result = (arg1)->GetTip();
8084 wxPyEndAllowThreads(__tstate);
8085 if (PyErr_Occurred()) SWIG_fail;
8086 }
8087 {
8088 #if wxUSE_UNICODE
8089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8090 #else
8091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8092 #endif
8093 }
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8101 PyObject *resultobj = 0;
8102 wxToolTip *arg1 = (wxToolTip *) 0 ;
8103 wxWindow *result = 0 ;
8104 void *argp1 = 0 ;
8105 int res1 = 0 ;
8106 PyObject *swig_obj[1] ;
8107
8108 if (!args) SWIG_fail;
8109 swig_obj[0] = args;
8110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8111 if (!SWIG_IsOK(res1)) {
8112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8113 }
8114 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8115 {
8116 PyThreadState* __tstate = wxPyBeginAllowThreads();
8117 result = (wxWindow *)(arg1)->GetWindow();
8118 wxPyEndAllowThreads(__tstate);
8119 if (PyErr_Occurred()) SWIG_fail;
8120 }
8121 {
8122 resultobj = wxPyMake_wxObject(result, 0);
8123 }
8124 return resultobj;
8125 fail:
8126 return NULL;
8127 }
8128
8129
8130 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8131 PyObject *resultobj = 0;
8132 bool arg1 ;
8133 bool val1 ;
8134 int ecode1 = 0 ;
8135 PyObject * obj0 = 0 ;
8136 char * kwnames[] = {
8137 (char *) "flag", NULL
8138 };
8139
8140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8141 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8142 if (!SWIG_IsOK(ecode1)) {
8143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8144 }
8145 arg1 = static_cast< bool >(val1);
8146 {
8147 PyThreadState* __tstate = wxPyBeginAllowThreads();
8148 wxToolTip::Enable(arg1);
8149 wxPyEndAllowThreads(__tstate);
8150 if (PyErr_Occurred()) SWIG_fail;
8151 }
8152 resultobj = SWIG_Py_Void();
8153 return resultobj;
8154 fail:
8155 return NULL;
8156 }
8157
8158
8159 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8160 PyObject *resultobj = 0;
8161 long arg1 ;
8162 long val1 ;
8163 int ecode1 = 0 ;
8164 PyObject * obj0 = 0 ;
8165 char * kwnames[] = {
8166 (char *) "milliseconds", NULL
8167 };
8168
8169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8170 ecode1 = SWIG_AsVal_long(obj0, &val1);
8171 if (!SWIG_IsOK(ecode1)) {
8172 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8173 }
8174 arg1 = static_cast< long >(val1);
8175 {
8176 PyThreadState* __tstate = wxPyBeginAllowThreads();
8177 wxToolTip::SetDelay(arg1);
8178 wxPyEndAllowThreads(__tstate);
8179 if (PyErr_Occurred()) SWIG_fail;
8180 }
8181 resultobj = SWIG_Py_Void();
8182 return resultobj;
8183 fail:
8184 return NULL;
8185 }
8186
8187
8188 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8189 PyObject *obj;
8190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8191 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8192 return SWIG_Py_Void();
8193 }
8194
8195 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8196 return SWIG_Python_InitShadowInstance(args);
8197 }
8198
8199 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8200 PyObject *resultobj = 0;
8201 wxWindow *arg1 = (wxWindow *) 0 ;
8202 wxSize *arg2 = 0 ;
8203 wxCaret *result = 0 ;
8204 void *argp1 = 0 ;
8205 int res1 = 0 ;
8206 wxSize temp2 ;
8207 PyObject * obj0 = 0 ;
8208 PyObject * obj1 = 0 ;
8209 char * kwnames[] = {
8210 (char *) "window",(char *) "size", NULL
8211 };
8212
8213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8215 if (!SWIG_IsOK(res1)) {
8216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8217 }
8218 arg1 = reinterpret_cast< wxWindow * >(argp1);
8219 {
8220 arg2 = &temp2;
8221 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8222 }
8223 {
8224 if (!wxPyCheckForApp()) SWIG_fail;
8225 PyThreadState* __tstate = wxPyBeginAllowThreads();
8226 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8227 wxPyEndAllowThreads(__tstate);
8228 if (PyErr_Occurred()) SWIG_fail;
8229 }
8230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8231 return resultobj;
8232 fail:
8233 return NULL;
8234 }
8235
8236
8237 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8238 PyObject *resultobj = 0;
8239 wxCaret *arg1 = (wxCaret *) 0 ;
8240 void *argp1 = 0 ;
8241 int res1 = 0 ;
8242 PyObject *swig_obj[1] ;
8243
8244 if (!args) SWIG_fail;
8245 swig_obj[0] = args;
8246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8247 if (!SWIG_IsOK(res1)) {
8248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8249 }
8250 arg1 = reinterpret_cast< wxCaret * >(argp1);
8251 {
8252 PyThreadState* __tstate = wxPyBeginAllowThreads();
8253 delete arg1;
8254
8255 wxPyEndAllowThreads(__tstate);
8256 if (PyErr_Occurred()) SWIG_fail;
8257 }
8258 resultobj = SWIG_Py_Void();
8259 return resultobj;
8260 fail:
8261 return NULL;
8262 }
8263
8264
8265 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8266 PyObject *resultobj = 0;
8267 wxCaret *arg1 = (wxCaret *) 0 ;
8268 void *argp1 = 0 ;
8269 int res1 = 0 ;
8270 PyObject *swig_obj[1] ;
8271
8272 if (!args) SWIG_fail;
8273 swig_obj[0] = args;
8274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8275 if (!SWIG_IsOK(res1)) {
8276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8277 }
8278 arg1 = reinterpret_cast< wxCaret * >(argp1);
8279 {
8280 PyThreadState* __tstate = wxPyBeginAllowThreads();
8281 wxCaret_Destroy(arg1);
8282 wxPyEndAllowThreads(__tstate);
8283 if (PyErr_Occurred()) SWIG_fail;
8284 }
8285 resultobj = SWIG_Py_Void();
8286 return resultobj;
8287 fail:
8288 return NULL;
8289 }
8290
8291
8292 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8293 PyObject *resultobj = 0;
8294 wxCaret *arg1 = (wxCaret *) 0 ;
8295 bool result;
8296 void *argp1 = 0 ;
8297 int res1 = 0 ;
8298 PyObject *swig_obj[1] ;
8299
8300 if (!args) SWIG_fail;
8301 swig_obj[0] = args;
8302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8303 if (!SWIG_IsOK(res1)) {
8304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8305 }
8306 arg1 = reinterpret_cast< wxCaret * >(argp1);
8307 {
8308 PyThreadState* __tstate = wxPyBeginAllowThreads();
8309 result = (bool)(arg1)->IsOk();
8310 wxPyEndAllowThreads(__tstate);
8311 if (PyErr_Occurred()) SWIG_fail;
8312 }
8313 {
8314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8315 }
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8323 PyObject *resultobj = 0;
8324 wxCaret *arg1 = (wxCaret *) 0 ;
8325 bool result;
8326 void *argp1 = 0 ;
8327 int res1 = 0 ;
8328 PyObject *swig_obj[1] ;
8329
8330 if (!args) SWIG_fail;
8331 swig_obj[0] = args;
8332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8333 if (!SWIG_IsOK(res1)) {
8334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8335 }
8336 arg1 = reinterpret_cast< wxCaret * >(argp1);
8337 {
8338 PyThreadState* __tstate = wxPyBeginAllowThreads();
8339 result = (bool)(arg1)->IsVisible();
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 {
8344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8345 }
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8353 PyObject *resultobj = 0;
8354 wxCaret *arg1 = (wxCaret *) 0 ;
8355 wxPoint result;
8356 void *argp1 = 0 ;
8357 int res1 = 0 ;
8358 PyObject *swig_obj[1] ;
8359
8360 if (!args) SWIG_fail;
8361 swig_obj[0] = args;
8362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8363 if (!SWIG_IsOK(res1)) {
8364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8365 }
8366 arg1 = reinterpret_cast< wxCaret * >(argp1);
8367 {
8368 PyThreadState* __tstate = wxPyBeginAllowThreads();
8369 result = (arg1)->GetPosition();
8370 wxPyEndAllowThreads(__tstate);
8371 if (PyErr_Occurred()) SWIG_fail;
8372 }
8373 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8374 return resultobj;
8375 fail:
8376 return NULL;
8377 }
8378
8379
8380 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8381 PyObject *resultobj = 0;
8382 wxCaret *arg1 = (wxCaret *) 0 ;
8383 int *arg2 = (int *) 0 ;
8384 int *arg3 = (int *) 0 ;
8385 void *argp1 = 0 ;
8386 int res1 = 0 ;
8387 int temp2 ;
8388 int res2 = SWIG_TMPOBJ ;
8389 int temp3 ;
8390 int res3 = SWIG_TMPOBJ ;
8391 PyObject *swig_obj[1] ;
8392
8393 arg2 = &temp2;
8394 arg3 = &temp3;
8395 if (!args) SWIG_fail;
8396 swig_obj[0] = args;
8397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8398 if (!SWIG_IsOK(res1)) {
8399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8400 }
8401 arg1 = reinterpret_cast< wxCaret * >(argp1);
8402 {
8403 PyThreadState* __tstate = wxPyBeginAllowThreads();
8404 (arg1)->GetPosition(arg2,arg3);
8405 wxPyEndAllowThreads(__tstate);
8406 if (PyErr_Occurred()) SWIG_fail;
8407 }
8408 resultobj = SWIG_Py_Void();
8409 if (SWIG_IsTmpObj(res2)) {
8410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8411 } else {
8412 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8413 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8414 }
8415 if (SWIG_IsTmpObj(res3)) {
8416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8417 } else {
8418 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8420 }
8421 return resultobj;
8422 fail:
8423 return NULL;
8424 }
8425
8426
8427 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8428 PyObject *resultobj = 0;
8429 wxCaret *arg1 = (wxCaret *) 0 ;
8430 wxSize result;
8431 void *argp1 = 0 ;
8432 int res1 = 0 ;
8433 PyObject *swig_obj[1] ;
8434
8435 if (!args) SWIG_fail;
8436 swig_obj[0] = args;
8437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8438 if (!SWIG_IsOK(res1)) {
8439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8440 }
8441 arg1 = reinterpret_cast< wxCaret * >(argp1);
8442 {
8443 PyThreadState* __tstate = wxPyBeginAllowThreads();
8444 result = (arg1)->GetSize();
8445 wxPyEndAllowThreads(__tstate);
8446 if (PyErr_Occurred()) SWIG_fail;
8447 }
8448 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8449 return resultobj;
8450 fail:
8451 return NULL;
8452 }
8453
8454
8455 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8456 PyObject *resultobj = 0;
8457 wxCaret *arg1 = (wxCaret *) 0 ;
8458 int *arg2 = (int *) 0 ;
8459 int *arg3 = (int *) 0 ;
8460 void *argp1 = 0 ;
8461 int res1 = 0 ;
8462 int temp2 ;
8463 int res2 = SWIG_TMPOBJ ;
8464 int temp3 ;
8465 int res3 = SWIG_TMPOBJ ;
8466 PyObject *swig_obj[1] ;
8467
8468 arg2 = &temp2;
8469 arg3 = &temp3;
8470 if (!args) SWIG_fail;
8471 swig_obj[0] = args;
8472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8475 }
8476 arg1 = reinterpret_cast< wxCaret * >(argp1);
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 (arg1)->GetSize(arg2,arg3);
8480 wxPyEndAllowThreads(__tstate);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 resultobj = SWIG_Py_Void();
8484 if (SWIG_IsTmpObj(res2)) {
8485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8486 } else {
8487 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8489 }
8490 if (SWIG_IsTmpObj(res3)) {
8491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8492 } else {
8493 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503 PyObject *resultobj = 0;
8504 wxCaret *arg1 = (wxCaret *) 0 ;
8505 wxWindow *result = 0 ;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 PyObject *swig_obj[1] ;
8509
8510 if (!args) SWIG_fail;
8511 swig_obj[0] = args;
8512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8515 }
8516 arg1 = reinterpret_cast< wxCaret * >(argp1);
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (wxWindow *)(arg1)->GetWindow();
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 {
8524 resultobj = wxPyMake_wxObject(result, 0);
8525 }
8526 return resultobj;
8527 fail:
8528 return NULL;
8529 }
8530
8531
8532 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8533 PyObject *resultobj = 0;
8534 wxCaret *arg1 = (wxCaret *) 0 ;
8535 int arg2 ;
8536 int arg3 ;
8537 void *argp1 = 0 ;
8538 int res1 = 0 ;
8539 int val2 ;
8540 int ecode2 = 0 ;
8541 int val3 ;
8542 int ecode3 = 0 ;
8543 PyObject * obj0 = 0 ;
8544 PyObject * obj1 = 0 ;
8545 PyObject * obj2 = 0 ;
8546 char * kwnames[] = {
8547 (char *) "self",(char *) "x",(char *) "y", NULL
8548 };
8549
8550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8552 if (!SWIG_IsOK(res1)) {
8553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8554 }
8555 arg1 = reinterpret_cast< wxCaret * >(argp1);
8556 ecode2 = SWIG_AsVal_int(obj1, &val2);
8557 if (!SWIG_IsOK(ecode2)) {
8558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8559 }
8560 arg2 = static_cast< int >(val2);
8561 ecode3 = SWIG_AsVal_int(obj2, &val3);
8562 if (!SWIG_IsOK(ecode3)) {
8563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8564 }
8565 arg3 = static_cast< int >(val3);
8566 {
8567 PyThreadState* __tstate = wxPyBeginAllowThreads();
8568 (arg1)->Move(arg2,arg3);
8569 wxPyEndAllowThreads(__tstate);
8570 if (PyErr_Occurred()) SWIG_fail;
8571 }
8572 resultobj = SWIG_Py_Void();
8573 return resultobj;
8574 fail:
8575 return NULL;
8576 }
8577
8578
8579 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8580 PyObject *resultobj = 0;
8581 wxCaret *arg1 = (wxCaret *) 0 ;
8582 wxPoint *arg2 = 0 ;
8583 void *argp1 = 0 ;
8584 int res1 = 0 ;
8585 wxPoint temp2 ;
8586 PyObject * obj0 = 0 ;
8587 PyObject * obj1 = 0 ;
8588 char * kwnames[] = {
8589 (char *) "self",(char *) "pt", NULL
8590 };
8591
8592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8594 if (!SWIG_IsOK(res1)) {
8595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8596 }
8597 arg1 = reinterpret_cast< wxCaret * >(argp1);
8598 {
8599 arg2 = &temp2;
8600 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8601 }
8602 {
8603 PyThreadState* __tstate = wxPyBeginAllowThreads();
8604 (arg1)->Move((wxPoint const &)*arg2);
8605 wxPyEndAllowThreads(__tstate);
8606 if (PyErr_Occurred()) SWIG_fail;
8607 }
8608 resultobj = SWIG_Py_Void();
8609 return resultobj;
8610 fail:
8611 return NULL;
8612 }
8613
8614
8615 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8616 PyObject *resultobj = 0;
8617 wxCaret *arg1 = (wxCaret *) 0 ;
8618 int arg2 ;
8619 int arg3 ;
8620 void *argp1 = 0 ;
8621 int res1 = 0 ;
8622 int val2 ;
8623 int ecode2 = 0 ;
8624 int val3 ;
8625 int ecode3 = 0 ;
8626 PyObject * obj0 = 0 ;
8627 PyObject * obj1 = 0 ;
8628 PyObject * obj2 = 0 ;
8629 char * kwnames[] = {
8630 (char *) "self",(char *) "width",(char *) "height", NULL
8631 };
8632
8633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8635 if (!SWIG_IsOK(res1)) {
8636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8637 }
8638 arg1 = reinterpret_cast< wxCaret * >(argp1);
8639 ecode2 = SWIG_AsVal_int(obj1, &val2);
8640 if (!SWIG_IsOK(ecode2)) {
8641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8642 }
8643 arg2 = static_cast< int >(val2);
8644 ecode3 = SWIG_AsVal_int(obj2, &val3);
8645 if (!SWIG_IsOK(ecode3)) {
8646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8647 }
8648 arg3 = static_cast< int >(val3);
8649 {
8650 PyThreadState* __tstate = wxPyBeginAllowThreads();
8651 (arg1)->SetSize(arg2,arg3);
8652 wxPyEndAllowThreads(__tstate);
8653 if (PyErr_Occurred()) SWIG_fail;
8654 }
8655 resultobj = SWIG_Py_Void();
8656 return resultobj;
8657 fail:
8658 return NULL;
8659 }
8660
8661
8662 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8663 PyObject *resultobj = 0;
8664 wxCaret *arg1 = (wxCaret *) 0 ;
8665 wxSize *arg2 = 0 ;
8666 void *argp1 = 0 ;
8667 int res1 = 0 ;
8668 wxSize temp2 ;
8669 PyObject * obj0 = 0 ;
8670 PyObject * obj1 = 0 ;
8671 char * kwnames[] = {
8672 (char *) "self",(char *) "size", NULL
8673 };
8674
8675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8677 if (!SWIG_IsOK(res1)) {
8678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8679 }
8680 arg1 = reinterpret_cast< wxCaret * >(argp1);
8681 {
8682 arg2 = &temp2;
8683 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8684 }
8685 {
8686 PyThreadState* __tstate = wxPyBeginAllowThreads();
8687 (arg1)->SetSize((wxSize const &)*arg2);
8688 wxPyEndAllowThreads(__tstate);
8689 if (PyErr_Occurred()) SWIG_fail;
8690 }
8691 resultobj = SWIG_Py_Void();
8692 return resultobj;
8693 fail:
8694 return NULL;
8695 }
8696
8697
8698 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8699 PyObject *resultobj = 0;
8700 wxCaret *arg1 = (wxCaret *) 0 ;
8701 int arg2 = (int) true ;
8702 void *argp1 = 0 ;
8703 int res1 = 0 ;
8704 int val2 ;
8705 int ecode2 = 0 ;
8706 PyObject * obj0 = 0 ;
8707 PyObject * obj1 = 0 ;
8708 char * kwnames[] = {
8709 (char *) "self",(char *) "show", NULL
8710 };
8711
8712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8714 if (!SWIG_IsOK(res1)) {
8715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8716 }
8717 arg1 = reinterpret_cast< wxCaret * >(argp1);
8718 if (obj1) {
8719 ecode2 = SWIG_AsVal_int(obj1, &val2);
8720 if (!SWIG_IsOK(ecode2)) {
8721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8722 }
8723 arg2 = static_cast< int >(val2);
8724 }
8725 {
8726 PyThreadState* __tstate = wxPyBeginAllowThreads();
8727 (arg1)->Show(arg2);
8728 wxPyEndAllowThreads(__tstate);
8729 if (PyErr_Occurred()) SWIG_fail;
8730 }
8731 resultobj = SWIG_Py_Void();
8732 return resultobj;
8733 fail:
8734 return NULL;
8735 }
8736
8737
8738 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8739 PyObject *resultobj = 0;
8740 wxCaret *arg1 = (wxCaret *) 0 ;
8741 void *argp1 = 0 ;
8742 int res1 = 0 ;
8743 PyObject *swig_obj[1] ;
8744
8745 if (!args) SWIG_fail;
8746 swig_obj[0] = args;
8747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8748 if (!SWIG_IsOK(res1)) {
8749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8750 }
8751 arg1 = reinterpret_cast< wxCaret * >(argp1);
8752 {
8753 PyThreadState* __tstate = wxPyBeginAllowThreads();
8754 (arg1)->Hide();
8755 wxPyEndAllowThreads(__tstate);
8756 if (PyErr_Occurred()) SWIG_fail;
8757 }
8758 resultobj = SWIG_Py_Void();
8759 return resultobj;
8760 fail:
8761 return NULL;
8762 }
8763
8764
8765 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8766 PyObject *resultobj = 0;
8767 int result;
8768
8769 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8770 {
8771 PyThreadState* __tstate = wxPyBeginAllowThreads();
8772 result = (int)wxCaret::GetBlinkTime();
8773 wxPyEndAllowThreads(__tstate);
8774 if (PyErr_Occurred()) SWIG_fail;
8775 }
8776 resultobj = SWIG_From_int(static_cast< int >(result));
8777 return resultobj;
8778 fail:
8779 return NULL;
8780 }
8781
8782
8783 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8784 PyObject *resultobj = 0;
8785 int arg1 ;
8786 int val1 ;
8787 int ecode1 = 0 ;
8788 PyObject * obj0 = 0 ;
8789 char * kwnames[] = {
8790 (char *) "milliseconds", NULL
8791 };
8792
8793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8794 ecode1 = SWIG_AsVal_int(obj0, &val1);
8795 if (!SWIG_IsOK(ecode1)) {
8796 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8797 }
8798 arg1 = static_cast< int >(val1);
8799 {
8800 PyThreadState* __tstate = wxPyBeginAllowThreads();
8801 wxCaret::SetBlinkTime(arg1);
8802 wxPyEndAllowThreads(__tstate);
8803 if (PyErr_Occurred()) SWIG_fail;
8804 }
8805 resultobj = SWIG_Py_Void();
8806 return resultobj;
8807 fail:
8808 return NULL;
8809 }
8810
8811
8812 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8813 PyObject *obj;
8814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8815 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8816 return SWIG_Py_Void();
8817 }
8818
8819 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8820 return SWIG_Python_InitShadowInstance(args);
8821 }
8822
8823 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8824 PyObject *resultobj = 0;
8825 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8826 wxBusyCursor *result = 0 ;
8827 void *argp1 = 0 ;
8828 int res1 = 0 ;
8829 PyObject * obj0 = 0 ;
8830 char * kwnames[] = {
8831 (char *) "cursor", NULL
8832 };
8833
8834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8835 if (obj0) {
8836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8837 if (!SWIG_IsOK(res1)) {
8838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8839 }
8840 arg1 = reinterpret_cast< wxCursor * >(argp1);
8841 }
8842 {
8843 if (!wxPyCheckForApp()) SWIG_fail;
8844 PyThreadState* __tstate = wxPyBeginAllowThreads();
8845 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8846 wxPyEndAllowThreads(__tstate);
8847 if (PyErr_Occurred()) SWIG_fail;
8848 }
8849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8850 return resultobj;
8851 fail:
8852 return NULL;
8853 }
8854
8855
8856 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8857 PyObject *resultobj = 0;
8858 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8859 void *argp1 = 0 ;
8860 int res1 = 0 ;
8861 PyObject *swig_obj[1] ;
8862
8863 if (!args) SWIG_fail;
8864 swig_obj[0] = args;
8865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8866 if (!SWIG_IsOK(res1)) {
8867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8868 }
8869 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8870 {
8871 PyThreadState* __tstate = wxPyBeginAllowThreads();
8872 delete arg1;
8873
8874 wxPyEndAllowThreads(__tstate);
8875 if (PyErr_Occurred()) SWIG_fail;
8876 }
8877 resultobj = SWIG_Py_Void();
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8885 PyObject *obj;
8886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8887 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8888 return SWIG_Py_Void();
8889 }
8890
8891 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8892 return SWIG_Python_InitShadowInstance(args);
8893 }
8894
8895 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8896 PyObject *resultobj = 0;
8897 wxWindow *arg1 = (wxWindow *) NULL ;
8898 wxWindowDisabler *result = 0 ;
8899 void *argp1 = 0 ;
8900 int res1 = 0 ;
8901 PyObject * obj0 = 0 ;
8902 char * kwnames[] = {
8903 (char *) "winToSkip", NULL
8904 };
8905
8906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8907 if (obj0) {
8908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8909 if (!SWIG_IsOK(res1)) {
8910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8911 }
8912 arg1 = reinterpret_cast< wxWindow * >(argp1);
8913 }
8914 {
8915 if (!wxPyCheckForApp()) SWIG_fail;
8916 PyThreadState* __tstate = wxPyBeginAllowThreads();
8917 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8922 return resultobj;
8923 fail:
8924 return NULL;
8925 }
8926
8927
8928 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8929 PyObject *resultobj = 0;
8930 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8931 void *argp1 = 0 ;
8932 int res1 = 0 ;
8933 PyObject *swig_obj[1] ;
8934
8935 if (!args) SWIG_fail;
8936 swig_obj[0] = args;
8937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8938 if (!SWIG_IsOK(res1)) {
8939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8940 }
8941 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8942 {
8943 PyThreadState* __tstate = wxPyBeginAllowThreads();
8944 delete arg1;
8945
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8957 PyObject *obj;
8958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8959 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8960 return SWIG_Py_Void();
8961 }
8962
8963 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8964 return SWIG_Python_InitShadowInstance(args);
8965 }
8966
8967 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8968 PyObject *resultobj = 0;
8969 wxString *arg1 = 0 ;
8970 wxBusyInfo *result = 0 ;
8971 bool temp1 = false ;
8972 PyObject * obj0 = 0 ;
8973 char * kwnames[] = {
8974 (char *) "message", NULL
8975 };
8976
8977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8978 {
8979 arg1 = wxString_in_helper(obj0);
8980 if (arg1 == NULL) SWIG_fail;
8981 temp1 = true;
8982 }
8983 {
8984 if (!wxPyCheckForApp()) SWIG_fail;
8985 PyThreadState* __tstate = wxPyBeginAllowThreads();
8986 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8987 wxPyEndAllowThreads(__tstate);
8988 if (PyErr_Occurred()) SWIG_fail;
8989 }
8990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8991 {
8992 if (temp1)
8993 delete arg1;
8994 }
8995 return resultobj;
8996 fail:
8997 {
8998 if (temp1)
8999 delete arg1;
9000 }
9001 return NULL;
9002 }
9003
9004
9005 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9006 PyObject *resultobj = 0;
9007 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9008 void *argp1 = 0 ;
9009 int res1 = 0 ;
9010 PyObject *swig_obj[1] ;
9011
9012 if (!args) SWIG_fail;
9013 swig_obj[0] = args;
9014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9015 if (!SWIG_IsOK(res1)) {
9016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9017 }
9018 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 delete arg1;
9022
9023 wxPyEndAllowThreads(__tstate);
9024 if (PyErr_Occurred()) SWIG_fail;
9025 }
9026 resultobj = SWIG_Py_Void();
9027 return resultobj;
9028 fail:
9029 return NULL;
9030 }
9031
9032
9033 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9034 PyObject *obj;
9035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9036 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9037 return SWIG_Py_Void();
9038 }
9039
9040 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9041 return SWIG_Python_InitShadowInstance(args);
9042 }
9043
9044 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9045 PyObject *resultobj = 0;
9046 wxStopWatch *result = 0 ;
9047
9048 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9049 {
9050 PyThreadState* __tstate = wxPyBeginAllowThreads();
9051 result = (wxStopWatch *)new wxStopWatch();
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9056 return resultobj;
9057 fail:
9058 return NULL;
9059 }
9060
9061
9062 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9063 PyObject *resultobj = 0;
9064 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9065 long arg2 = (long) 0 ;
9066 void *argp1 = 0 ;
9067 int res1 = 0 ;
9068 long val2 ;
9069 int ecode2 = 0 ;
9070 PyObject * obj0 = 0 ;
9071 PyObject * obj1 = 0 ;
9072 char * kwnames[] = {
9073 (char *) "self",(char *) "t0", NULL
9074 };
9075
9076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9078 if (!SWIG_IsOK(res1)) {
9079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9080 }
9081 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9082 if (obj1) {
9083 ecode2 = SWIG_AsVal_long(obj1, &val2);
9084 if (!SWIG_IsOK(ecode2)) {
9085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9086 }
9087 arg2 = static_cast< long >(val2);
9088 }
9089 {
9090 PyThreadState* __tstate = wxPyBeginAllowThreads();
9091 (arg1)->Start(arg2);
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 resultobj = SWIG_Py_Void();
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 PyObject *resultobj = 0;
9104 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9105 void *argp1 = 0 ;
9106 int res1 = 0 ;
9107 PyObject *swig_obj[1] ;
9108
9109 if (!args) SWIG_fail;
9110 swig_obj[0] = args;
9111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9112 if (!SWIG_IsOK(res1)) {
9113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9114 }
9115 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9116 {
9117 PyThreadState* __tstate = wxPyBeginAllowThreads();
9118 (arg1)->Pause();
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 resultobj = SWIG_Py_Void();
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9130 PyObject *resultobj = 0;
9131 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9132 void *argp1 = 0 ;
9133 int res1 = 0 ;
9134 PyObject *swig_obj[1] ;
9135
9136 if (!args) SWIG_fail;
9137 swig_obj[0] = args;
9138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9139 if (!SWIG_IsOK(res1)) {
9140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9141 }
9142 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9143 {
9144 PyThreadState* __tstate = wxPyBeginAllowThreads();
9145 (arg1)->Resume();
9146 wxPyEndAllowThreads(__tstate);
9147 if (PyErr_Occurred()) SWIG_fail;
9148 }
9149 resultobj = SWIG_Py_Void();
9150 return resultobj;
9151 fail:
9152 return NULL;
9153 }
9154
9155
9156 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9157 PyObject *resultobj = 0;
9158 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9159 long result;
9160 void *argp1 = 0 ;
9161 int res1 = 0 ;
9162 PyObject *swig_obj[1] ;
9163
9164 if (!args) SWIG_fail;
9165 swig_obj[0] = args;
9166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9167 if (!SWIG_IsOK(res1)) {
9168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9169 }
9170 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 result = (long)((wxStopWatch const *)arg1)->Time();
9174 wxPyEndAllowThreads(__tstate);
9175 if (PyErr_Occurred()) SWIG_fail;
9176 }
9177 resultobj = SWIG_From_long(static_cast< long >(result));
9178 return resultobj;
9179 fail:
9180 return NULL;
9181 }
9182
9183
9184 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9185 PyObject *obj;
9186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9187 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9188 return SWIG_Py_Void();
9189 }
9190
9191 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9192 return SWIG_Python_InitShadowInstance(args);
9193 }
9194
9195 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9196 PyObject *resultobj = 0;
9197 int arg1 = (int) 9 ;
9198 int arg2 = (int) wxID_FILE1 ;
9199 wxFileHistory *result = 0 ;
9200 int val1 ;
9201 int ecode1 = 0 ;
9202 int val2 ;
9203 int ecode2 = 0 ;
9204 PyObject * obj0 = 0 ;
9205 PyObject * obj1 = 0 ;
9206 char * kwnames[] = {
9207 (char *) "maxFiles",(char *) "idBase", NULL
9208 };
9209
9210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9211 if (obj0) {
9212 ecode1 = SWIG_AsVal_int(obj0, &val1);
9213 if (!SWIG_IsOK(ecode1)) {
9214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9215 }
9216 arg1 = static_cast< int >(val1);
9217 }
9218 if (obj1) {
9219 ecode2 = SWIG_AsVal_int(obj1, &val2);
9220 if (!SWIG_IsOK(ecode2)) {
9221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9222 }
9223 arg2 = static_cast< int >(val2);
9224 }
9225 {
9226 PyThreadState* __tstate = wxPyBeginAllowThreads();
9227 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9232 return resultobj;
9233 fail:
9234 return NULL;
9235 }
9236
9237
9238 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9239 PyObject *resultobj = 0;
9240 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9241 void *argp1 = 0 ;
9242 int res1 = 0 ;
9243 PyObject *swig_obj[1] ;
9244
9245 if (!args) SWIG_fail;
9246 swig_obj[0] = args;
9247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9248 if (!SWIG_IsOK(res1)) {
9249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9250 }
9251 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9252 {
9253 PyThreadState* __tstate = wxPyBeginAllowThreads();
9254 delete arg1;
9255
9256 wxPyEndAllowThreads(__tstate);
9257 if (PyErr_Occurred()) SWIG_fail;
9258 }
9259 resultobj = SWIG_Py_Void();
9260 return resultobj;
9261 fail:
9262 return NULL;
9263 }
9264
9265
9266 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9267 PyObject *resultobj = 0;
9268 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9269 wxString *arg2 = 0 ;
9270 void *argp1 = 0 ;
9271 int res1 = 0 ;
9272 bool temp2 = false ;
9273 PyObject * obj0 = 0 ;
9274 PyObject * obj1 = 0 ;
9275 char * kwnames[] = {
9276 (char *) "self",(char *) "file", NULL
9277 };
9278
9279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9281 if (!SWIG_IsOK(res1)) {
9282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9283 }
9284 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9285 {
9286 arg2 = wxString_in_helper(obj1);
9287 if (arg2 == NULL) SWIG_fail;
9288 temp2 = true;
9289 }
9290 {
9291 PyThreadState* __tstate = wxPyBeginAllowThreads();
9292 (arg1)->AddFileToHistory((wxString const &)*arg2);
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 resultobj = SWIG_Py_Void();
9297 {
9298 if (temp2)
9299 delete arg2;
9300 }
9301 return resultobj;
9302 fail:
9303 {
9304 if (temp2)
9305 delete arg2;
9306 }
9307 return NULL;
9308 }
9309
9310
9311 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9312 PyObject *resultobj = 0;
9313 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9314 int arg2 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 int val2 ;
9318 int ecode2 = 0 ;
9319 PyObject * obj0 = 0 ;
9320 PyObject * obj1 = 0 ;
9321 char * kwnames[] = {
9322 (char *) "self",(char *) "i", NULL
9323 };
9324
9325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9327 if (!SWIG_IsOK(res1)) {
9328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9329 }
9330 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9331 ecode2 = SWIG_AsVal_int(obj1, &val2);
9332 if (!SWIG_IsOK(ecode2)) {
9333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9334 }
9335 arg2 = static_cast< int >(val2);
9336 {
9337 PyThreadState* __tstate = wxPyBeginAllowThreads();
9338 (arg1)->RemoveFileFromHistory(arg2);
9339 wxPyEndAllowThreads(__tstate);
9340 if (PyErr_Occurred()) SWIG_fail;
9341 }
9342 resultobj = SWIG_Py_Void();
9343 return resultobj;
9344 fail:
9345 return NULL;
9346 }
9347
9348
9349 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9350 PyObject *resultobj = 0;
9351 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9352 int result;
9353 void *argp1 = 0 ;
9354 int res1 = 0 ;
9355 PyObject *swig_obj[1] ;
9356
9357 if (!args) SWIG_fail;
9358 swig_obj[0] = args;
9359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9360 if (!SWIG_IsOK(res1)) {
9361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9362 }
9363 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9364 {
9365 PyThreadState* __tstate = wxPyBeginAllowThreads();
9366 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9367 wxPyEndAllowThreads(__tstate);
9368 if (PyErr_Occurred()) SWIG_fail;
9369 }
9370 resultobj = SWIG_From_int(static_cast< int >(result));
9371 return resultobj;
9372 fail:
9373 return NULL;
9374 }
9375
9376
9377 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9378 PyObject *resultobj = 0;
9379 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9380 wxMenu *arg2 = (wxMenu *) 0 ;
9381 void *argp1 = 0 ;
9382 int res1 = 0 ;
9383 void *argp2 = 0 ;
9384 int res2 = 0 ;
9385 PyObject * obj0 = 0 ;
9386 PyObject * obj1 = 0 ;
9387 char * kwnames[] = {
9388 (char *) "self",(char *) "menu", NULL
9389 };
9390
9391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9393 if (!SWIG_IsOK(res1)) {
9394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9395 }
9396 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9397 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9398 if (!SWIG_IsOK(res2)) {
9399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9400 }
9401 arg2 = reinterpret_cast< wxMenu * >(argp2);
9402 {
9403 PyThreadState* __tstate = wxPyBeginAllowThreads();
9404 (arg1)->UseMenu(arg2);
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 resultobj = SWIG_Py_Void();
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9416 PyObject *resultobj = 0;
9417 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9418 wxMenu *arg2 = (wxMenu *) 0 ;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 void *argp2 = 0 ;
9422 int res2 = 0 ;
9423 PyObject * obj0 = 0 ;
9424 PyObject * obj1 = 0 ;
9425 char * kwnames[] = {
9426 (char *) "self",(char *) "menu", NULL
9427 };
9428
9429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9431 if (!SWIG_IsOK(res1)) {
9432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9433 }
9434 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9435 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9436 if (!SWIG_IsOK(res2)) {
9437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9438 }
9439 arg2 = reinterpret_cast< wxMenu * >(argp2);
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 (arg1)->RemoveMenu(arg2);
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 resultobj = SWIG_Py_Void();
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj = 0;
9455 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9456 wxConfigBase *arg2 = 0 ;
9457 void *argp1 = 0 ;
9458 int res1 = 0 ;
9459 void *argp2 = 0 ;
9460 int res2 = 0 ;
9461 PyObject * obj0 = 0 ;
9462 PyObject * obj1 = 0 ;
9463 char * kwnames[] = {
9464 (char *) "self",(char *) "config", NULL
9465 };
9466
9467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9469 if (!SWIG_IsOK(res1)) {
9470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9471 }
9472 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9473 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9474 if (!SWIG_IsOK(res2)) {
9475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9476 }
9477 if (!argp2) {
9478 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9479 }
9480 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9481 {
9482 PyThreadState* __tstate = wxPyBeginAllowThreads();
9483 (arg1)->Load(*arg2);
9484 wxPyEndAllowThreads(__tstate);
9485 if (PyErr_Occurred()) SWIG_fail;
9486 }
9487 resultobj = SWIG_Py_Void();
9488 return resultobj;
9489 fail:
9490 return NULL;
9491 }
9492
9493
9494 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9495 PyObject *resultobj = 0;
9496 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9497 wxConfigBase *arg2 = 0 ;
9498 void *argp1 = 0 ;
9499 int res1 = 0 ;
9500 void *argp2 = 0 ;
9501 int res2 = 0 ;
9502 PyObject * obj0 = 0 ;
9503 PyObject * obj1 = 0 ;
9504 char * kwnames[] = {
9505 (char *) "self",(char *) "config", NULL
9506 };
9507
9508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9510 if (!SWIG_IsOK(res1)) {
9511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9512 }
9513 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9514 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9515 if (!SWIG_IsOK(res2)) {
9516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9517 }
9518 if (!argp2) {
9519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9520 }
9521 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 (arg1)->Save(*arg2);
9525 wxPyEndAllowThreads(__tstate);
9526 if (PyErr_Occurred()) SWIG_fail;
9527 }
9528 resultobj = SWIG_Py_Void();
9529 return resultobj;
9530 fail:
9531 return NULL;
9532 }
9533
9534
9535 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9536 PyObject *resultobj = 0;
9537 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9538 void *argp1 = 0 ;
9539 int res1 = 0 ;
9540 PyObject *swig_obj[1] ;
9541
9542 if (!args) SWIG_fail;
9543 swig_obj[0] = args;
9544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9545 if (!SWIG_IsOK(res1)) {
9546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9547 }
9548 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9549 {
9550 PyThreadState* __tstate = wxPyBeginAllowThreads();
9551 (arg1)->AddFilesToMenu();
9552 wxPyEndAllowThreads(__tstate);
9553 if (PyErr_Occurred()) SWIG_fail;
9554 }
9555 resultobj = SWIG_Py_Void();
9556 return resultobj;
9557 fail:
9558 return NULL;
9559 }
9560
9561
9562 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9563 PyObject *resultobj = 0;
9564 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9565 wxMenu *arg2 = (wxMenu *) 0 ;
9566 void *argp1 = 0 ;
9567 int res1 = 0 ;
9568 void *argp2 = 0 ;
9569 int res2 = 0 ;
9570 PyObject * obj0 = 0 ;
9571 PyObject * obj1 = 0 ;
9572 char * kwnames[] = {
9573 (char *) "self",(char *) "menu", NULL
9574 };
9575
9576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9578 if (!SWIG_IsOK(res1)) {
9579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9580 }
9581 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9582 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9583 if (!SWIG_IsOK(res2)) {
9584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9585 }
9586 arg2 = reinterpret_cast< wxMenu * >(argp2);
9587 {
9588 PyThreadState* __tstate = wxPyBeginAllowThreads();
9589 (arg1)->AddFilesToMenu(arg2);
9590 wxPyEndAllowThreads(__tstate);
9591 if (PyErr_Occurred()) SWIG_fail;
9592 }
9593 resultobj = SWIG_Py_Void();
9594 return resultobj;
9595 fail:
9596 return NULL;
9597 }
9598
9599
9600 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9601 PyObject *resultobj = 0;
9602 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9603 int arg2 ;
9604 wxString result;
9605 void *argp1 = 0 ;
9606 int res1 = 0 ;
9607 int val2 ;
9608 int ecode2 = 0 ;
9609 PyObject * obj0 = 0 ;
9610 PyObject * obj1 = 0 ;
9611 char * kwnames[] = {
9612 (char *) "self",(char *) "i", NULL
9613 };
9614
9615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9617 if (!SWIG_IsOK(res1)) {
9618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9619 }
9620 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9621 ecode2 = SWIG_AsVal_int(obj1, &val2);
9622 if (!SWIG_IsOK(ecode2)) {
9623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9624 }
9625 arg2 = static_cast< int >(val2);
9626 {
9627 PyThreadState* __tstate = wxPyBeginAllowThreads();
9628 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 {
9633 #if wxUSE_UNICODE
9634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9635 #else
9636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9637 #endif
9638 }
9639 return resultobj;
9640 fail:
9641 return NULL;
9642 }
9643
9644
9645 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9646 PyObject *resultobj = 0;
9647 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9648 int result;
9649 void *argp1 = 0 ;
9650 int res1 = 0 ;
9651 PyObject *swig_obj[1] ;
9652
9653 if (!args) SWIG_fail;
9654 swig_obj[0] = args;
9655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9656 if (!SWIG_IsOK(res1)) {
9657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9658 }
9659 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9660 {
9661 PyThreadState* __tstate = wxPyBeginAllowThreads();
9662 result = (int)((wxFileHistory const *)arg1)->GetCount();
9663 wxPyEndAllowThreads(__tstate);
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = SWIG_From_int(static_cast< int >(result));
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9674 PyObject *obj;
9675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9676 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9677 return SWIG_Py_Void();
9678 }
9679
9680 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9681 return SWIG_Python_InitShadowInstance(args);
9682 }
9683
9684 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9685 PyObject *resultobj = 0;
9686 wxString *arg1 = 0 ;
9687 wxString const &arg2_defvalue = wxPyEmptyString ;
9688 wxString *arg2 = (wxString *) &arg2_defvalue ;
9689 wxSingleInstanceChecker *result = 0 ;
9690 bool temp1 = false ;
9691 bool temp2 = false ;
9692 PyObject * obj0 = 0 ;
9693 PyObject * obj1 = 0 ;
9694 char * kwnames[] = {
9695 (char *) "name",(char *) "path", NULL
9696 };
9697
9698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9699 {
9700 arg1 = wxString_in_helper(obj0);
9701 if (arg1 == NULL) SWIG_fail;
9702 temp1 = true;
9703 }
9704 if (obj1) {
9705 {
9706 arg2 = wxString_in_helper(obj1);
9707 if (arg2 == NULL) SWIG_fail;
9708 temp2 = true;
9709 }
9710 }
9711 {
9712 PyThreadState* __tstate = wxPyBeginAllowThreads();
9713 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9718 {
9719 if (temp1)
9720 delete arg1;
9721 }
9722 {
9723 if (temp2)
9724 delete arg2;
9725 }
9726 return resultobj;
9727 fail:
9728 {
9729 if (temp1)
9730 delete arg1;
9731 }
9732 {
9733 if (temp2)
9734 delete arg2;
9735 }
9736 return NULL;
9737 }
9738
9739
9740 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9741 PyObject *resultobj = 0;
9742 wxSingleInstanceChecker *result = 0 ;
9743
9744 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9745 {
9746 PyThreadState* __tstate = wxPyBeginAllowThreads();
9747 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9748 wxPyEndAllowThreads(__tstate);
9749 if (PyErr_Occurred()) SWIG_fail;
9750 }
9751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9752 return resultobj;
9753 fail:
9754 return NULL;
9755 }
9756
9757
9758 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9759 PyObject *resultobj = 0;
9760 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9761 void *argp1 = 0 ;
9762 int res1 = 0 ;
9763 PyObject *swig_obj[1] ;
9764
9765 if (!args) SWIG_fail;
9766 swig_obj[0] = args;
9767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9768 if (!SWIG_IsOK(res1)) {
9769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9770 }
9771 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9772 {
9773 PyThreadState* __tstate = wxPyBeginAllowThreads();
9774 delete arg1;
9775
9776 wxPyEndAllowThreads(__tstate);
9777 if (PyErr_Occurred()) SWIG_fail;
9778 }
9779 resultobj = SWIG_Py_Void();
9780 return resultobj;
9781 fail:
9782 return NULL;
9783 }
9784
9785
9786 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9787 PyObject *resultobj = 0;
9788 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9789 wxString *arg2 = 0 ;
9790 wxString const &arg3_defvalue = wxPyEmptyString ;
9791 wxString *arg3 = (wxString *) &arg3_defvalue ;
9792 bool result;
9793 void *argp1 = 0 ;
9794 int res1 = 0 ;
9795 bool temp2 = false ;
9796 bool temp3 = false ;
9797 PyObject * obj0 = 0 ;
9798 PyObject * obj1 = 0 ;
9799 PyObject * obj2 = 0 ;
9800 char * kwnames[] = {
9801 (char *) "self",(char *) "name",(char *) "path", NULL
9802 };
9803
9804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9806 if (!SWIG_IsOK(res1)) {
9807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9808 }
9809 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9810 {
9811 arg2 = wxString_in_helper(obj1);
9812 if (arg2 == NULL) SWIG_fail;
9813 temp2 = true;
9814 }
9815 if (obj2) {
9816 {
9817 arg3 = wxString_in_helper(obj2);
9818 if (arg3 == NULL) SWIG_fail;
9819 temp3 = true;
9820 }
9821 }
9822 {
9823 PyThreadState* __tstate = wxPyBeginAllowThreads();
9824 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9825 wxPyEndAllowThreads(__tstate);
9826 if (PyErr_Occurred()) SWIG_fail;
9827 }
9828 {
9829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9830 }
9831 {
9832 if (temp2)
9833 delete arg2;
9834 }
9835 {
9836 if (temp3)
9837 delete arg3;
9838 }
9839 return resultobj;
9840 fail:
9841 {
9842 if (temp2)
9843 delete arg2;
9844 }
9845 {
9846 if (temp3)
9847 delete arg3;
9848 }
9849 return NULL;
9850 }
9851
9852
9853 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9854 PyObject *resultobj = 0;
9855 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9856 bool result;
9857 void *argp1 = 0 ;
9858 int res1 = 0 ;
9859 PyObject *swig_obj[1] ;
9860
9861 if (!args) SWIG_fail;
9862 swig_obj[0] = args;
9863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9864 if (!SWIG_IsOK(res1)) {
9865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9866 }
9867 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9871 wxPyEndAllowThreads(__tstate);
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 {
9875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9876 }
9877 return resultobj;
9878 fail:
9879 return NULL;
9880 }
9881
9882
9883 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9884 PyObject *obj;
9885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9886 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9887 return SWIG_Py_Void();
9888 }
9889
9890 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9891 return SWIG_Python_InitShadowInstance(args);
9892 }
9893
9894 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9895 PyObject *resultobj = 0;
9896 wxWindow *arg1 = (wxWindow *) 0 ;
9897 wxDC *arg2 = 0 ;
9898 bool result;
9899 void *argp1 = 0 ;
9900 int res1 = 0 ;
9901 void *argp2 = 0 ;
9902 int res2 = 0 ;
9903 PyObject * obj0 = 0 ;
9904 PyObject * obj1 = 0 ;
9905 char * kwnames[] = {
9906 (char *) "window",(char *) "dc", NULL
9907 };
9908
9909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9911 if (!SWIG_IsOK(res1)) {
9912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9913 }
9914 arg1 = reinterpret_cast< wxWindow * >(argp1);
9915 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9916 if (!SWIG_IsOK(res2)) {
9917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9918 }
9919 if (!argp2) {
9920 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9921 }
9922 arg2 = reinterpret_cast< wxDC * >(argp2);
9923 {
9924 PyThreadState* __tstate = wxPyBeginAllowThreads();
9925 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9926 wxPyEndAllowThreads(__tstate);
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 {
9930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9931 }
9932 return resultobj;
9933 fail:
9934 return NULL;
9935 }
9936
9937
9938 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9939 PyObject *resultobj = 0;
9940 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9941 void *argp1 = 0 ;
9942 int res1 = 0 ;
9943 PyObject *swig_obj[1] ;
9944
9945 if (!args) SWIG_fail;
9946 swig_obj[0] = args;
9947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9948 if (!SWIG_IsOK(res1)) {
9949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9950 }
9951 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9952 {
9953 PyThreadState* __tstate = wxPyBeginAllowThreads();
9954 delete arg1;
9955
9956 wxPyEndAllowThreads(__tstate);
9957 if (PyErr_Occurred()) SWIG_fail;
9958 }
9959 resultobj = SWIG_Py_Void();
9960 return resultobj;
9961 fail:
9962 return NULL;
9963 }
9964
9965
9966 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9967 PyObject *resultobj = 0;
9968 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9969 wxString result;
9970 void *argp1 = 0 ;
9971 int res1 = 0 ;
9972 PyObject *swig_obj[1] ;
9973
9974 if (!args) SWIG_fail;
9975 swig_obj[0] = args;
9976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9977 if (!SWIG_IsOK(res1)) {
9978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9979 }
9980 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9981 {
9982 PyThreadState* __tstate = wxPyBeginAllowThreads();
9983 result = (arg1)->GetTip();
9984 wxPyEndAllowThreads(__tstate);
9985 if (PyErr_Occurred()) SWIG_fail;
9986 }
9987 {
9988 #if wxUSE_UNICODE
9989 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9990 #else
9991 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9992 #endif
9993 }
9994 return resultobj;
9995 fail:
9996 return NULL;
9997 }
9998
9999
10000 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10001 PyObject *resultobj = 0;
10002 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10003 size_t result;
10004 void *argp1 = 0 ;
10005 int res1 = 0 ;
10006 PyObject *swig_obj[1] ;
10007
10008 if (!args) SWIG_fail;
10009 swig_obj[0] = args;
10010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10011 if (!SWIG_IsOK(res1)) {
10012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10013 }
10014 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 result = (size_t)(arg1)->GetCurrentTip();
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10022 return resultobj;
10023 fail:
10024 return NULL;
10025 }
10026
10027
10028 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10029 PyObject *resultobj = 0;
10030 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10031 wxString *arg2 = 0 ;
10032 wxString result;
10033 void *argp1 = 0 ;
10034 int res1 = 0 ;
10035 bool temp2 = false ;
10036 PyObject * obj0 = 0 ;
10037 PyObject * obj1 = 0 ;
10038 char * kwnames[] = {
10039 (char *) "self",(char *) "tip", NULL
10040 };
10041
10042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10044 if (!SWIG_IsOK(res1)) {
10045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10046 }
10047 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10048 {
10049 arg2 = wxString_in_helper(obj1);
10050 if (arg2 == NULL) SWIG_fail;
10051 temp2 = true;
10052 }
10053 {
10054 PyThreadState* __tstate = wxPyBeginAllowThreads();
10055 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10056 wxPyEndAllowThreads(__tstate);
10057 if (PyErr_Occurred()) SWIG_fail;
10058 }
10059 {
10060 #if wxUSE_UNICODE
10061 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10062 #else
10063 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10064 #endif
10065 }
10066 {
10067 if (temp2)
10068 delete arg2;
10069 }
10070 return resultobj;
10071 fail:
10072 {
10073 if (temp2)
10074 delete arg2;
10075 }
10076 return NULL;
10077 }
10078
10079
10080 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10081 PyObject *obj;
10082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10083 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10084 return SWIG_Py_Void();
10085 }
10086
10087 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj = 0;
10089 size_t arg1 ;
10090 wxPyTipProvider *result = 0 ;
10091 size_t val1 ;
10092 int ecode1 = 0 ;
10093 PyObject * obj0 = 0 ;
10094 char * kwnames[] = {
10095 (char *) "currentTip", NULL
10096 };
10097
10098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10099 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10100 if (!SWIG_IsOK(ecode1)) {
10101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10102 }
10103 arg1 = static_cast< size_t >(val1);
10104 {
10105 PyThreadState* __tstate = wxPyBeginAllowThreads();
10106 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10107 wxPyEndAllowThreads(__tstate);
10108 if (PyErr_Occurred()) SWIG_fail;
10109 }
10110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10118 PyObject *resultobj = 0;
10119 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10120 PyObject *arg2 = (PyObject *) 0 ;
10121 PyObject *arg3 = (PyObject *) 0 ;
10122 void *argp1 = 0 ;
10123 int res1 = 0 ;
10124 PyObject * obj0 = 0 ;
10125 PyObject * obj1 = 0 ;
10126 PyObject * obj2 = 0 ;
10127 char * kwnames[] = {
10128 (char *) "self",(char *) "self",(char *) "_class", NULL
10129 };
10130
10131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10133 if (!SWIG_IsOK(res1)) {
10134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10135 }
10136 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10137 arg2 = obj1;
10138 arg3 = obj2;
10139 {
10140 PyThreadState* __tstate = wxPyBeginAllowThreads();
10141 (arg1)->_setCallbackInfo(arg2,arg3);
10142 wxPyEndAllowThreads(__tstate);
10143 if (PyErr_Occurred()) SWIG_fail;
10144 }
10145 resultobj = SWIG_Py_Void();
10146 return resultobj;
10147 fail:
10148 return NULL;
10149 }
10150
10151
10152 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10153 PyObject *obj;
10154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10155 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10156 return SWIG_Py_Void();
10157 }
10158
10159 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10160 return SWIG_Python_InitShadowInstance(args);
10161 }
10162
10163 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj = 0;
10165 wxWindow *arg1 = (wxWindow *) 0 ;
10166 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10167 bool arg3 = (bool) true ;
10168 bool result;
10169 void *argp1 = 0 ;
10170 int res1 = 0 ;
10171 void *argp2 = 0 ;
10172 int res2 = 0 ;
10173 bool val3 ;
10174 int ecode3 = 0 ;
10175 PyObject * obj0 = 0 ;
10176 PyObject * obj1 = 0 ;
10177 PyObject * obj2 = 0 ;
10178 char * kwnames[] = {
10179 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10180 };
10181
10182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10184 if (!SWIG_IsOK(res1)) {
10185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10186 }
10187 arg1 = reinterpret_cast< wxWindow * >(argp1);
10188 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10189 if (!SWIG_IsOK(res2)) {
10190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10191 }
10192 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10193 if (obj2) {
10194 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10195 if (!SWIG_IsOK(ecode3)) {
10196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10197 }
10198 arg3 = static_cast< bool >(val3);
10199 }
10200 {
10201 if (!wxPyCheckForApp()) SWIG_fail;
10202 PyThreadState* __tstate = wxPyBeginAllowThreads();
10203 result = (bool)wxShowTip(arg1,arg2,arg3);
10204 wxPyEndAllowThreads(__tstate);
10205 if (PyErr_Occurred()) SWIG_fail;
10206 }
10207 {
10208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10209 }
10210 return resultobj;
10211 fail:
10212 return NULL;
10213 }
10214
10215
10216 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10217 PyObject *resultobj = 0;
10218 wxString *arg1 = 0 ;
10219 size_t arg2 ;
10220 wxTipProvider *result = 0 ;
10221 bool temp1 = false ;
10222 size_t val2 ;
10223 int ecode2 = 0 ;
10224 PyObject * obj0 = 0 ;
10225 PyObject * obj1 = 0 ;
10226 char * kwnames[] = {
10227 (char *) "filename",(char *) "currentTip", NULL
10228 };
10229
10230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10231 {
10232 arg1 = wxString_in_helper(obj0);
10233 if (arg1 == NULL) SWIG_fail;
10234 temp1 = true;
10235 }
10236 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10237 if (!SWIG_IsOK(ecode2)) {
10238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10239 }
10240 arg2 = static_cast< size_t >(val2);
10241 {
10242 if (!wxPyCheckForApp()) SWIG_fail;
10243 PyThreadState* __tstate = wxPyBeginAllowThreads();
10244 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10245 wxPyEndAllowThreads(__tstate);
10246 if (PyErr_Occurred()) SWIG_fail;
10247 }
10248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10249 {
10250 if (temp1)
10251 delete arg1;
10252 }
10253 return resultobj;
10254 fail:
10255 {
10256 if (temp1)
10257 delete arg1;
10258 }
10259 return NULL;
10260 }
10261
10262
10263 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10264 PyObject *resultobj = 0;
10265 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10266 int arg2 = (int) wxID_ANY ;
10267 wxPyTimer *result = 0 ;
10268 void *argp1 = 0 ;
10269 int res1 = 0 ;
10270 int val2 ;
10271 int ecode2 = 0 ;
10272 PyObject * obj0 = 0 ;
10273 PyObject * obj1 = 0 ;
10274 char * kwnames[] = {
10275 (char *) "owner",(char *) "id", NULL
10276 };
10277
10278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10279 if (obj0) {
10280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10281 if (!SWIG_IsOK(res1)) {
10282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10283 }
10284 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10285 }
10286 if (obj1) {
10287 ecode2 = SWIG_AsVal_int(obj1, &val2);
10288 if (!SWIG_IsOK(ecode2)) {
10289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10290 }
10291 arg2 = static_cast< int >(val2);
10292 }
10293 {
10294 if (!wxPyCheckForApp()) SWIG_fail;
10295 PyThreadState* __tstate = wxPyBeginAllowThreads();
10296 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10297 wxPyEndAllowThreads(__tstate);
10298 if (PyErr_Occurred()) SWIG_fail;
10299 }
10300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10301 return resultobj;
10302 fail:
10303 return NULL;
10304 }
10305
10306
10307 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10308 PyObject *resultobj = 0;
10309 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10310 void *argp1 = 0 ;
10311 int res1 = 0 ;
10312 PyObject *swig_obj[1] ;
10313
10314 if (!args) SWIG_fail;
10315 swig_obj[0] = args;
10316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10319 }
10320 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10321 {
10322 PyThreadState* __tstate = wxPyBeginAllowThreads();
10323 delete arg1;
10324
10325 wxPyEndAllowThreads(__tstate);
10326 if (PyErr_Occurred()) SWIG_fail;
10327 }
10328 resultobj = SWIG_Py_Void();
10329 return resultobj;
10330 fail:
10331 return NULL;
10332 }
10333
10334
10335 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10336 PyObject *resultobj = 0;
10337 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10338 PyObject *arg2 = (PyObject *) 0 ;
10339 PyObject *arg3 = (PyObject *) 0 ;
10340 int arg4 = (int) 1 ;
10341 void *argp1 = 0 ;
10342 int res1 = 0 ;
10343 int val4 ;
10344 int ecode4 = 0 ;
10345 PyObject * obj0 = 0 ;
10346 PyObject * obj1 = 0 ;
10347 PyObject * obj2 = 0 ;
10348 PyObject * obj3 = 0 ;
10349 char * kwnames[] = {
10350 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10351 };
10352
10353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10355 if (!SWIG_IsOK(res1)) {
10356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10357 }
10358 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10359 arg2 = obj1;
10360 arg3 = obj2;
10361 if (obj3) {
10362 ecode4 = SWIG_AsVal_int(obj3, &val4);
10363 if (!SWIG_IsOK(ecode4)) {
10364 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10365 }
10366 arg4 = static_cast< int >(val4);
10367 }
10368 {
10369 PyThreadState* __tstate = wxPyBeginAllowThreads();
10370 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10371 wxPyEndAllowThreads(__tstate);
10372 if (PyErr_Occurred()) SWIG_fail;
10373 }
10374 resultobj = SWIG_Py_Void();
10375 return resultobj;
10376 fail:
10377 return NULL;
10378 }
10379
10380
10381 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10382 PyObject *resultobj = 0;
10383 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10384 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10385 int arg3 = (int) wxID_ANY ;
10386 void *argp1 = 0 ;
10387 int res1 = 0 ;
10388 void *argp2 = 0 ;
10389 int res2 = 0 ;
10390 int val3 ;
10391 int ecode3 = 0 ;
10392 PyObject * obj0 = 0 ;
10393 PyObject * obj1 = 0 ;
10394 PyObject * obj2 = 0 ;
10395 char * kwnames[] = {
10396 (char *) "self",(char *) "owner",(char *) "id", NULL
10397 };
10398
10399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10401 if (!SWIG_IsOK(res1)) {
10402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10403 }
10404 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10406 if (!SWIG_IsOK(res2)) {
10407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10408 }
10409 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10410 if (obj2) {
10411 ecode3 = SWIG_AsVal_int(obj2, &val3);
10412 if (!SWIG_IsOK(ecode3)) {
10413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10414 }
10415 arg3 = static_cast< int >(val3);
10416 }
10417 {
10418 PyThreadState* __tstate = wxPyBeginAllowThreads();
10419 (arg1)->SetOwner(arg2,arg3);
10420 wxPyEndAllowThreads(__tstate);
10421 if (PyErr_Occurred()) SWIG_fail;
10422 }
10423 resultobj = SWIG_Py_Void();
10424 return resultobj;
10425 fail:
10426 return NULL;
10427 }
10428
10429
10430 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10431 PyObject *resultobj = 0;
10432 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10433 wxEvtHandler *result = 0 ;
10434 void *argp1 = 0 ;
10435 int res1 = 0 ;
10436 PyObject *swig_obj[1] ;
10437
10438 if (!args) SWIG_fail;
10439 swig_obj[0] = args;
10440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10441 if (!SWIG_IsOK(res1)) {
10442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10443 }
10444 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10445 {
10446 PyThreadState* __tstate = wxPyBeginAllowThreads();
10447 result = (wxEvtHandler *)(arg1)->GetOwner();
10448 wxPyEndAllowThreads(__tstate);
10449 if (PyErr_Occurred()) SWIG_fail;
10450 }
10451 {
10452 resultobj = wxPyMake_wxObject(result, 0);
10453 }
10454 return resultobj;
10455 fail:
10456 return NULL;
10457 }
10458
10459
10460 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10461 PyObject *resultobj = 0;
10462 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10463 int arg2 = (int) -1 ;
10464 bool arg3 = (bool) false ;
10465 bool result;
10466 void *argp1 = 0 ;
10467 int res1 = 0 ;
10468 int val2 ;
10469 int ecode2 = 0 ;
10470 bool val3 ;
10471 int ecode3 = 0 ;
10472 PyObject * obj0 = 0 ;
10473 PyObject * obj1 = 0 ;
10474 PyObject * obj2 = 0 ;
10475 char * kwnames[] = {
10476 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10477 };
10478
10479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10481 if (!SWIG_IsOK(res1)) {
10482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10483 }
10484 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10485 if (obj1) {
10486 ecode2 = SWIG_AsVal_int(obj1, &val2);
10487 if (!SWIG_IsOK(ecode2)) {
10488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10489 }
10490 arg2 = static_cast< int >(val2);
10491 }
10492 if (obj2) {
10493 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10494 if (!SWIG_IsOK(ecode3)) {
10495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10496 }
10497 arg3 = static_cast< bool >(val3);
10498 }
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 result = (bool)(arg1)->Start(arg2,arg3);
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 {
10506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10507 }
10508 return resultobj;
10509 fail:
10510 return NULL;
10511 }
10512
10513
10514 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10515 PyObject *resultobj = 0;
10516 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10517 void *argp1 = 0 ;
10518 int res1 = 0 ;
10519 PyObject *swig_obj[1] ;
10520
10521 if (!args) SWIG_fail;
10522 swig_obj[0] = args;
10523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10524 if (!SWIG_IsOK(res1)) {
10525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10526 }
10527 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10528 {
10529 PyThreadState* __tstate = wxPyBeginAllowThreads();
10530 (arg1)->Stop();
10531 wxPyEndAllowThreads(__tstate);
10532 if (PyErr_Occurred()) SWIG_fail;
10533 }
10534 resultobj = SWIG_Py_Void();
10535 return resultobj;
10536 fail:
10537 return NULL;
10538 }
10539
10540
10541 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10542 PyObject *resultobj = 0;
10543 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10544 void *argp1 = 0 ;
10545 int res1 = 0 ;
10546 PyObject *swig_obj[1] ;
10547
10548 if (!args) SWIG_fail;
10549 swig_obj[0] = args;
10550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10553 }
10554 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 (arg1)->Notify();
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_Py_Void();
10562 return resultobj;
10563 fail:
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *resultobj = 0;
10570 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10571 bool result;
10572 void *argp1 = 0 ;
10573 int res1 = 0 ;
10574 PyObject *swig_obj[1] ;
10575
10576 if (!args) SWIG_fail;
10577 swig_obj[0] = args;
10578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10579 if (!SWIG_IsOK(res1)) {
10580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10581 }
10582 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 {
10590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10591 }
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10599 PyObject *resultobj = 0;
10600 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10601 int result;
10602 void *argp1 = 0 ;
10603 int res1 = 0 ;
10604 PyObject *swig_obj[1] ;
10605
10606 if (!args) SWIG_fail;
10607 swig_obj[0] = args;
10608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10609 if (!SWIG_IsOK(res1)) {
10610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10611 }
10612 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10613 {
10614 PyThreadState* __tstate = wxPyBeginAllowThreads();
10615 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10616 wxPyEndAllowThreads(__tstate);
10617 if (PyErr_Occurred()) SWIG_fail;
10618 }
10619 resultobj = SWIG_From_int(static_cast< int >(result));
10620 return resultobj;
10621 fail:
10622 return NULL;
10623 }
10624
10625
10626 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10627 PyObject *resultobj = 0;
10628 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10629 int result;
10630 void *argp1 = 0 ;
10631 int res1 = 0 ;
10632 PyObject *swig_obj[1] ;
10633
10634 if (!args) SWIG_fail;
10635 swig_obj[0] = args;
10636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10637 if (!SWIG_IsOK(res1)) {
10638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10639 }
10640 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10641 {
10642 PyThreadState* __tstate = wxPyBeginAllowThreads();
10643 result = (int)((wxPyTimer const *)arg1)->GetId();
10644 wxPyEndAllowThreads(__tstate);
10645 if (PyErr_Occurred()) SWIG_fail;
10646 }
10647 resultobj = SWIG_From_int(static_cast< int >(result));
10648 return resultobj;
10649 fail:
10650 return NULL;
10651 }
10652
10653
10654 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10655 PyObject *resultobj = 0;
10656 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10657 bool result;
10658 void *argp1 = 0 ;
10659 int res1 = 0 ;
10660 PyObject *swig_obj[1] ;
10661
10662 if (!args) SWIG_fail;
10663 swig_obj[0] = args;
10664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10665 if (!SWIG_IsOK(res1)) {
10666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10667 }
10668 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10669 {
10670 PyThreadState* __tstate = wxPyBeginAllowThreads();
10671 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10672 wxPyEndAllowThreads(__tstate);
10673 if (PyErr_Occurred()) SWIG_fail;
10674 }
10675 {
10676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10677 }
10678 return resultobj;
10679 fail:
10680 return NULL;
10681 }
10682
10683
10684 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10685 PyObject *obj;
10686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10687 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10688 return SWIG_Py_Void();
10689 }
10690
10691 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10692 return SWIG_Python_InitShadowInstance(args);
10693 }
10694
10695 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10696 PyObject *resultobj = 0;
10697 int arg1 = (int) 0 ;
10698 int arg2 = (int) 0 ;
10699 wxTimerEvent *result = 0 ;
10700 int val1 ;
10701 int ecode1 = 0 ;
10702 int val2 ;
10703 int ecode2 = 0 ;
10704 PyObject * obj0 = 0 ;
10705 PyObject * obj1 = 0 ;
10706 char * kwnames[] = {
10707 (char *) "timerid",(char *) "interval", NULL
10708 };
10709
10710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10711 if (obj0) {
10712 ecode1 = SWIG_AsVal_int(obj0, &val1);
10713 if (!SWIG_IsOK(ecode1)) {
10714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10715 }
10716 arg1 = static_cast< int >(val1);
10717 }
10718 if (obj1) {
10719 ecode2 = SWIG_AsVal_int(obj1, &val2);
10720 if (!SWIG_IsOK(ecode2)) {
10721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10722 }
10723 arg2 = static_cast< int >(val2);
10724 }
10725 {
10726 PyThreadState* __tstate = wxPyBeginAllowThreads();
10727 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10728 wxPyEndAllowThreads(__tstate);
10729 if (PyErr_Occurred()) SWIG_fail;
10730 }
10731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10732 return resultobj;
10733 fail:
10734 return NULL;
10735 }
10736
10737
10738 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10739 PyObject *resultobj = 0;
10740 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10741 int result;
10742 void *argp1 = 0 ;
10743 int res1 = 0 ;
10744 PyObject *swig_obj[1] ;
10745
10746 if (!args) SWIG_fail;
10747 swig_obj[0] = args;
10748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10749 if (!SWIG_IsOK(res1)) {
10750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10751 }
10752 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10753 {
10754 PyThreadState* __tstate = wxPyBeginAllowThreads();
10755 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10756 wxPyEndAllowThreads(__tstate);
10757 if (PyErr_Occurred()) SWIG_fail;
10758 }
10759 resultobj = SWIG_From_int(static_cast< int >(result));
10760 return resultobj;
10761 fail:
10762 return NULL;
10763 }
10764
10765
10766 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10767 PyObject *obj;
10768 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10769 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10770 return SWIG_Py_Void();
10771 }
10772
10773 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10774 return SWIG_Python_InitShadowInstance(args);
10775 }
10776
10777 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10778 PyObject *resultobj = 0;
10779 wxTimer *arg1 = 0 ;
10780 wxTimerRunner *result = 0 ;
10781 void *argp1 = 0 ;
10782 int res1 = 0 ;
10783
10784 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10786 if (!SWIG_IsOK(res1)) {
10787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10788 }
10789 if (!argp1) {
10790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10791 }
10792 arg1 = reinterpret_cast< wxTimer * >(argp1);
10793 {
10794 if (!wxPyCheckForApp()) SWIG_fail;
10795 PyThreadState* __tstate = wxPyBeginAllowThreads();
10796 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10797 wxPyEndAllowThreads(__tstate);
10798 if (PyErr_Occurred()) SWIG_fail;
10799 }
10800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10801 return resultobj;
10802 fail:
10803 return NULL;
10804 }
10805
10806
10807 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10808 PyObject *resultobj = 0;
10809 wxTimer *arg1 = 0 ;
10810 int arg2 ;
10811 bool arg3 = (bool) false ;
10812 wxTimerRunner *result = 0 ;
10813 void *argp1 = 0 ;
10814 int res1 = 0 ;
10815 int val2 ;
10816 int ecode2 = 0 ;
10817 bool val3 ;
10818 int ecode3 = 0 ;
10819
10820 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10822 if (!SWIG_IsOK(res1)) {
10823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10824 }
10825 if (!argp1) {
10826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10827 }
10828 arg1 = reinterpret_cast< wxTimer * >(argp1);
10829 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10830 if (!SWIG_IsOK(ecode2)) {
10831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10832 }
10833 arg2 = static_cast< int >(val2);
10834 if (swig_obj[2]) {
10835 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10836 if (!SWIG_IsOK(ecode3)) {
10837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10838 }
10839 arg3 = static_cast< bool >(val3);
10840 }
10841 {
10842 if (!wxPyCheckForApp()) SWIG_fail;
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10856 int argc;
10857 PyObject *argv[4];
10858
10859 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10860 --argc;
10861 if (argc == 1) {
10862 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10863 }
10864 if ((argc >= 2) && (argc <= 3)) {
10865 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10866 }
10867
10868 fail:
10869 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10875 PyObject *resultobj = 0;
10876 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10877 void *argp1 = 0 ;
10878 int res1 = 0 ;
10879 PyObject *swig_obj[1] ;
10880
10881 if (!args) SWIG_fail;
10882 swig_obj[0] = args;
10883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10884 if (!SWIG_IsOK(res1)) {
10885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10886 }
10887 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10888 {
10889 PyThreadState* __tstate = wxPyBeginAllowThreads();
10890 delete arg1;
10891
10892 wxPyEndAllowThreads(__tstate);
10893 if (PyErr_Occurred()) SWIG_fail;
10894 }
10895 resultobj = SWIG_Py_Void();
10896 return resultobj;
10897 fail:
10898 return NULL;
10899 }
10900
10901
10902 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10903 PyObject *resultobj = 0;
10904 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10905 int arg2 ;
10906 bool arg3 = (bool) false ;
10907 void *argp1 = 0 ;
10908 int res1 = 0 ;
10909 int val2 ;
10910 int ecode2 = 0 ;
10911 bool val3 ;
10912 int ecode3 = 0 ;
10913 PyObject * obj0 = 0 ;
10914 PyObject * obj1 = 0 ;
10915 PyObject * obj2 = 0 ;
10916 char * kwnames[] = {
10917 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10918 };
10919
10920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10922 if (!SWIG_IsOK(res1)) {
10923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10924 }
10925 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10926 ecode2 = SWIG_AsVal_int(obj1, &val2);
10927 if (!SWIG_IsOK(ecode2)) {
10928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10929 }
10930 arg2 = static_cast< int >(val2);
10931 if (obj2) {
10932 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10933 if (!SWIG_IsOK(ecode3)) {
10934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10935 }
10936 arg3 = static_cast< bool >(val3);
10937 }
10938 {
10939 PyThreadState* __tstate = wxPyBeginAllowThreads();
10940 (arg1)->Start(arg2,arg3);
10941 wxPyEndAllowThreads(__tstate);
10942 if (PyErr_Occurred()) SWIG_fail;
10943 }
10944 resultobj = SWIG_Py_Void();
10945 return resultobj;
10946 fail:
10947 return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10952 PyObject *obj;
10953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10954 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10955 return SWIG_Py_Void();
10956 }
10957
10958 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10959 return SWIG_Python_InitShadowInstance(args);
10960 }
10961
10962 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10963 PyObject *resultobj = 0;
10964 wxLog *result = 0 ;
10965
10966 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10967 {
10968 PyThreadState* __tstate = wxPyBeginAllowThreads();
10969 result = (wxLog *)new wxLog();
10970 wxPyEndAllowThreads(__tstate);
10971 if (PyErr_Occurred()) SWIG_fail;
10972 }
10973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10974 return resultobj;
10975 fail:
10976 return NULL;
10977 }
10978
10979
10980 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10981 PyObject *resultobj = 0;
10982 wxLog *arg1 = (wxLog *) 0 ;
10983 void *argp1 = 0 ;
10984 int res1 = 0 ;
10985 PyObject *swig_obj[1] ;
10986
10987 if (!args) SWIG_fail;
10988 swig_obj[0] = args;
10989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10990 if (!SWIG_IsOK(res1)) {
10991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
10992 }
10993 arg1 = reinterpret_cast< wxLog * >(argp1);
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 delete arg1;
10997
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 resultobj = SWIG_Py_Void();
11002 return resultobj;
11003 fail:
11004 return NULL;
11005 }
11006
11007
11008 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11009 PyObject *resultobj = 0;
11010 bool result;
11011
11012 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11013 {
11014 PyThreadState* __tstate = wxPyBeginAllowThreads();
11015 result = (bool)wxLog::IsEnabled();
11016 wxPyEndAllowThreads(__tstate);
11017 if (PyErr_Occurred()) SWIG_fail;
11018 }
11019 {
11020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11021 }
11022 return resultobj;
11023 fail:
11024 return NULL;
11025 }
11026
11027
11028 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11029 PyObject *resultobj = 0;
11030 bool arg1 = (bool) true ;
11031 bool result;
11032 bool val1 ;
11033 int ecode1 = 0 ;
11034 PyObject * obj0 = 0 ;
11035 char * kwnames[] = {
11036 (char *) "doIt", NULL
11037 };
11038
11039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11040 if (obj0) {
11041 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11042 if (!SWIG_IsOK(ecode1)) {
11043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11044 }
11045 arg1 = static_cast< bool >(val1);
11046 }
11047 {
11048 PyThreadState* __tstate = wxPyBeginAllowThreads();
11049 result = (bool)wxLog::EnableLogging(arg1);
11050 wxPyEndAllowThreads(__tstate);
11051 if (PyErr_Occurred()) SWIG_fail;
11052 }
11053 {
11054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11055 }
11056 return resultobj;
11057 fail:
11058 return NULL;
11059 }
11060
11061
11062 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11063 PyObject *resultobj = 0;
11064 wxLogLevel arg1 ;
11065 wxChar *arg2 = (wxChar *) 0 ;
11066 time_t arg3 ;
11067 unsigned long val1 ;
11068 int ecode1 = 0 ;
11069 void *argp2 = 0 ;
11070 int res2 = 0 ;
11071 unsigned int val3 ;
11072 int ecode3 = 0 ;
11073 PyObject * obj0 = 0 ;
11074 PyObject * obj1 = 0 ;
11075 PyObject * obj2 = 0 ;
11076 char * kwnames[] = {
11077 (char *) "level",(char *) "szString",(char *) "t", NULL
11078 };
11079
11080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11081 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11082 if (!SWIG_IsOK(ecode1)) {
11083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11084 }
11085 arg1 = static_cast< wxLogLevel >(val1);
11086 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11087 if (!SWIG_IsOK(res2)) {
11088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11089 }
11090 arg2 = reinterpret_cast< wxChar * >(argp2);
11091 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11092 if (!SWIG_IsOK(ecode3)) {
11093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11094 }
11095 arg3 = static_cast< time_t >(val3);
11096 {
11097 PyThreadState* __tstate = wxPyBeginAllowThreads();
11098 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11099 wxPyEndAllowThreads(__tstate);
11100 if (PyErr_Occurred()) SWIG_fail;
11101 }
11102 resultobj = SWIG_Py_Void();
11103 return resultobj;
11104 fail:
11105 return NULL;
11106 }
11107
11108
11109 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11110 PyObject *resultobj = 0;
11111 wxLog *arg1 = (wxLog *) 0 ;
11112 void *argp1 = 0 ;
11113 int res1 = 0 ;
11114 PyObject *swig_obj[1] ;
11115
11116 if (!args) SWIG_fail;
11117 swig_obj[0] = args;
11118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11119 if (!SWIG_IsOK(res1)) {
11120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11121 }
11122 arg1 = reinterpret_cast< wxLog * >(argp1);
11123 {
11124 PyThreadState* __tstate = wxPyBeginAllowThreads();
11125 (arg1)->Flush();
11126 wxPyEndAllowThreads(__tstate);
11127 if (PyErr_Occurred()) SWIG_fail;
11128 }
11129 resultobj = SWIG_Py_Void();
11130 return resultobj;
11131 fail:
11132 return NULL;
11133 }
11134
11135
11136 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11137 PyObject *resultobj = 0;
11138
11139 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11140 {
11141 PyThreadState* __tstate = wxPyBeginAllowThreads();
11142 wxLog::FlushActive();
11143 wxPyEndAllowThreads(__tstate);
11144 if (PyErr_Occurred()) SWIG_fail;
11145 }
11146 resultobj = SWIG_Py_Void();
11147 return resultobj;
11148 fail:
11149 return NULL;
11150 }
11151
11152
11153 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11154 PyObject *resultobj = 0;
11155 wxLog *result = 0 ;
11156
11157 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11158 {
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (wxLog *)wxLog::GetActiveTarget();
11161 wxPyEndAllowThreads(__tstate);
11162 if (PyErr_Occurred()) SWIG_fail;
11163 }
11164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11165 return resultobj;
11166 fail:
11167 return NULL;
11168 }
11169
11170
11171 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11172 PyObject *resultobj = 0;
11173 wxLog *arg1 = (wxLog *) 0 ;
11174 wxLog *result = 0 ;
11175 int res1 = 0 ;
11176 PyObject * obj0 = 0 ;
11177 char * kwnames[] = {
11178 (char *) "pLogger", NULL
11179 };
11180
11181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11182 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11183 if (!SWIG_IsOK(res1)) {
11184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11185 }
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11189 wxPyEndAllowThreads(__tstate);
11190 if (PyErr_Occurred()) SWIG_fail;
11191 }
11192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11193 return resultobj;
11194 fail:
11195 return NULL;
11196 }
11197
11198
11199 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11200 PyObject *resultobj = 0;
11201
11202 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11203 {
11204 PyThreadState* __tstate = wxPyBeginAllowThreads();
11205 wxLog::Suspend();
11206 wxPyEndAllowThreads(__tstate);
11207 if (PyErr_Occurred()) SWIG_fail;
11208 }
11209 resultobj = SWIG_Py_Void();
11210 return resultobj;
11211 fail:
11212 return NULL;
11213 }
11214
11215
11216 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11217 PyObject *resultobj = 0;
11218
11219 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11220 {
11221 PyThreadState* __tstate = wxPyBeginAllowThreads();
11222 wxLog::Resume();
11223 wxPyEndAllowThreads(__tstate);
11224 if (PyErr_Occurred()) SWIG_fail;
11225 }
11226 resultobj = SWIG_Py_Void();
11227 return resultobj;
11228 fail:
11229 return NULL;
11230 }
11231
11232
11233 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11234 PyObject *resultobj = 0;
11235 bool arg1 = (bool) true ;
11236 bool val1 ;
11237 int ecode1 = 0 ;
11238 PyObject * obj0 = 0 ;
11239 char * kwnames[] = {
11240 (char *) "bVerbose", NULL
11241 };
11242
11243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11244 if (obj0) {
11245 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11246 if (!SWIG_IsOK(ecode1)) {
11247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11248 }
11249 arg1 = static_cast< bool >(val1);
11250 }
11251 {
11252 PyThreadState* __tstate = wxPyBeginAllowThreads();
11253 wxLog::SetVerbose(arg1);
11254 wxPyEndAllowThreads(__tstate);
11255 if (PyErr_Occurred()) SWIG_fail;
11256 }
11257 resultobj = SWIG_Py_Void();
11258 return resultobj;
11259 fail:
11260 return NULL;
11261 }
11262
11263
11264 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11265 PyObject *resultobj = 0;
11266 wxLogLevel arg1 ;
11267 unsigned long val1 ;
11268 int ecode1 = 0 ;
11269 PyObject * obj0 = 0 ;
11270 char * kwnames[] = {
11271 (char *) "logLevel", NULL
11272 };
11273
11274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11275 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11276 if (!SWIG_IsOK(ecode1)) {
11277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11278 }
11279 arg1 = static_cast< wxLogLevel >(val1);
11280 {
11281 PyThreadState* __tstate = wxPyBeginAllowThreads();
11282 wxLog::SetLogLevel(arg1);
11283 wxPyEndAllowThreads(__tstate);
11284 if (PyErr_Occurred()) SWIG_fail;
11285 }
11286 resultobj = SWIG_Py_Void();
11287 return resultobj;
11288 fail:
11289 return NULL;
11290 }
11291
11292
11293 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11294 PyObject *resultobj = 0;
11295
11296 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11297 {
11298 PyThreadState* __tstate = wxPyBeginAllowThreads();
11299 wxLog::DontCreateOnDemand();
11300 wxPyEndAllowThreads(__tstate);
11301 if (PyErr_Occurred()) SWIG_fail;
11302 }
11303 resultobj = SWIG_Py_Void();
11304 return resultobj;
11305 fail:
11306 return NULL;
11307 }
11308
11309
11310 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11311 PyObject *resultobj = 0;
11312 wxTraceMask arg1 ;
11313 unsigned long val1 ;
11314 int ecode1 = 0 ;
11315 PyObject * obj0 = 0 ;
11316 char * kwnames[] = {
11317 (char *) "ulMask", NULL
11318 };
11319
11320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11321 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11322 if (!SWIG_IsOK(ecode1)) {
11323 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11324 }
11325 arg1 = static_cast< wxTraceMask >(val1);
11326 {
11327 PyThreadState* __tstate = wxPyBeginAllowThreads();
11328 wxLog::SetTraceMask(arg1);
11329 wxPyEndAllowThreads(__tstate);
11330 if (PyErr_Occurred()) SWIG_fail;
11331 }
11332 resultobj = SWIG_Py_Void();
11333 return resultobj;
11334 fail:
11335 return NULL;
11336 }
11337
11338
11339 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11340 PyObject *resultobj = 0;
11341 wxString *arg1 = 0 ;
11342 bool temp1 = false ;
11343 PyObject * obj0 = 0 ;
11344 char * kwnames[] = {
11345 (char *) "str", NULL
11346 };
11347
11348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11349 {
11350 arg1 = wxString_in_helper(obj0);
11351 if (arg1 == NULL) SWIG_fail;
11352 temp1 = true;
11353 }
11354 {
11355 PyThreadState* __tstate = wxPyBeginAllowThreads();
11356 wxLog::AddTraceMask((wxString const &)*arg1);
11357 wxPyEndAllowThreads(__tstate);
11358 if (PyErr_Occurred()) SWIG_fail;
11359 }
11360 resultobj = SWIG_Py_Void();
11361 {
11362 if (temp1)
11363 delete arg1;
11364 }
11365 return resultobj;
11366 fail:
11367 {
11368 if (temp1)
11369 delete arg1;
11370 }
11371 return NULL;
11372 }
11373
11374
11375 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11376 PyObject *resultobj = 0;
11377 wxString *arg1 = 0 ;
11378 bool temp1 = false ;
11379 PyObject * obj0 = 0 ;
11380 char * kwnames[] = {
11381 (char *) "str", NULL
11382 };
11383
11384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11385 {
11386 arg1 = wxString_in_helper(obj0);
11387 if (arg1 == NULL) SWIG_fail;
11388 temp1 = true;
11389 }
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 wxLog::RemoveTraceMask((wxString const &)*arg1);
11393 wxPyEndAllowThreads(__tstate);
11394 if (PyErr_Occurred()) SWIG_fail;
11395 }
11396 resultobj = SWIG_Py_Void();
11397 {
11398 if (temp1)
11399 delete arg1;
11400 }
11401 return resultobj;
11402 fail:
11403 {
11404 if (temp1)
11405 delete arg1;
11406 }
11407 return NULL;
11408 }
11409
11410
11411 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11412 PyObject *resultobj = 0;
11413
11414 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11415 {
11416 PyThreadState* __tstate = wxPyBeginAllowThreads();
11417 wxLog::ClearTraceMasks();
11418 wxPyEndAllowThreads(__tstate);
11419 if (PyErr_Occurred()) SWIG_fail;
11420 }
11421 resultobj = SWIG_Py_Void();
11422 return resultobj;
11423 fail:
11424 return NULL;
11425 }
11426
11427
11428 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11429 PyObject *resultobj = 0;
11430 wxArrayString *result = 0 ;
11431
11432 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11433 {
11434 PyThreadState* __tstate = wxPyBeginAllowThreads();
11435 {
11436 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11437 result = (wxArrayString *) &_result_ref;
11438 }
11439 wxPyEndAllowThreads(__tstate);
11440 if (PyErr_Occurred()) SWIG_fail;
11441 }
11442 {
11443 resultobj = wxArrayString2PyList_helper(*result);
11444 }
11445 return resultobj;
11446 fail:
11447 return NULL;
11448 }
11449
11450
11451 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj = 0;
11453 wxChar *arg1 = (wxChar *) 0 ;
11454 void *argp1 = 0 ;
11455 int res1 = 0 ;
11456 PyObject * obj0 = 0 ;
11457 char * kwnames[] = {
11458 (char *) "ts", NULL
11459 };
11460
11461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11463 if (!SWIG_IsOK(res1)) {
11464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11465 }
11466 arg1 = reinterpret_cast< wxChar * >(argp1);
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 wxLog::SetTimestamp((wxChar const *)arg1);
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 resultobj = SWIG_Py_Void();
11474 return resultobj;
11475 fail:
11476 return NULL;
11477 }
11478
11479
11480 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11481 PyObject *resultobj = 0;
11482 bool result;
11483
11484 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11485 {
11486 PyThreadState* __tstate = wxPyBeginAllowThreads();
11487 result = (bool)wxLog::GetVerbose();
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 {
11492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11493 }
11494 return resultobj;
11495 fail:
11496 return NULL;
11497 }
11498
11499
11500 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11501 PyObject *resultobj = 0;
11502 wxTraceMask result;
11503
11504 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11505 {
11506 PyThreadState* __tstate = wxPyBeginAllowThreads();
11507 result = (wxTraceMask)wxLog::GetTraceMask();
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj = 0;
11520 wxChar *arg1 = (wxChar *) 0 ;
11521 bool result;
11522 void *argp1 = 0 ;
11523 int res1 = 0 ;
11524 PyObject * obj0 = 0 ;
11525 char * kwnames[] = {
11526 (char *) "mask", NULL
11527 };
11528
11529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11531 if (!SWIG_IsOK(res1)) {
11532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11533 }
11534 arg1 = reinterpret_cast< wxChar * >(argp1);
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 {
11542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11543 }
11544 return resultobj;
11545 fail:
11546 return NULL;
11547 }
11548
11549
11550 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11551 PyObject *resultobj = 0;
11552 wxLogLevel result;
11553
11554 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11555 {
11556 PyThreadState* __tstate = wxPyBeginAllowThreads();
11557 result = (wxLogLevel)wxLog::GetLogLevel();
11558 wxPyEndAllowThreads(__tstate);
11559 if (PyErr_Occurred()) SWIG_fail;
11560 }
11561 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11562 return resultobj;
11563 fail:
11564 return NULL;
11565 }
11566
11567
11568 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11569 PyObject *resultobj = 0;
11570 wxChar *result = 0 ;
11571
11572 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 result = (wxChar *)wxLog::GetTimestamp();
11576 wxPyEndAllowThreads(__tstate);
11577 if (PyErr_Occurred()) SWIG_fail;
11578 }
11579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11580 return resultobj;
11581 fail:
11582 return NULL;
11583 }
11584
11585
11586 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11587 PyObject *resultobj = 0;
11588 wxString result;
11589
11590 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11591 {
11592 PyThreadState* __tstate = wxPyBeginAllowThreads();
11593 result = wxLog_TimeStamp();
11594 wxPyEndAllowThreads(__tstate);
11595 if (PyErr_Occurred()) SWIG_fail;
11596 }
11597 {
11598 #if wxUSE_UNICODE
11599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11600 #else
11601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11602 #endif
11603 }
11604 return resultobj;
11605 fail:
11606 return NULL;
11607 }
11608
11609
11610 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11611 PyObject *resultobj = 0;
11612 wxLog *arg1 = (wxLog *) 0 ;
11613 void *argp1 = 0 ;
11614 int res1 = 0 ;
11615 PyObject *swig_obj[1] ;
11616
11617 if (!args) SWIG_fail;
11618 swig_obj[0] = args;
11619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11620 if (!SWIG_IsOK(res1)) {
11621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11622 }
11623 arg1 = reinterpret_cast< wxLog * >(argp1);
11624 {
11625 PyThreadState* __tstate = wxPyBeginAllowThreads();
11626 wxLog_Destroy(arg1);
11627 wxPyEndAllowThreads(__tstate);
11628 if (PyErr_Occurred()) SWIG_fail;
11629 }
11630 resultobj = SWIG_Py_Void();
11631 return resultobj;
11632 fail:
11633 return NULL;
11634 }
11635
11636
11637 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11638 PyObject *obj;
11639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11640 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11641 return SWIG_Py_Void();
11642 }
11643
11644 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11645 return SWIG_Python_InitShadowInstance(args);
11646 }
11647
11648 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11649 PyObject *resultobj = 0;
11650 wxLogStderr *result = 0 ;
11651
11652 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (wxLogStderr *)new wxLogStderr();
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11660 return resultobj;
11661 fail:
11662 return NULL;
11663 }
11664
11665
11666 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11667 PyObject *obj;
11668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11669 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11670 return SWIG_Py_Void();
11671 }
11672
11673 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11674 return SWIG_Python_InitShadowInstance(args);
11675 }
11676
11677 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj = 0;
11679 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11680 wxLogTextCtrl *result = 0 ;
11681 void *argp1 = 0 ;
11682 int res1 = 0 ;
11683 PyObject * obj0 = 0 ;
11684 char * kwnames[] = {
11685 (char *) "pTextCtrl", NULL
11686 };
11687
11688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11690 if (!SWIG_IsOK(res1)) {
11691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11692 }
11693 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11694 {
11695 PyThreadState* __tstate = wxPyBeginAllowThreads();
11696 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11697 wxPyEndAllowThreads(__tstate);
11698 if (PyErr_Occurred()) SWIG_fail;
11699 }
11700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11701 return resultobj;
11702 fail:
11703 return NULL;
11704 }
11705
11706
11707 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11708 PyObject *obj;
11709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11710 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11711 return SWIG_Py_Void();
11712 }
11713
11714 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11715 return SWIG_Python_InitShadowInstance(args);
11716 }
11717
11718 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11719 PyObject *resultobj = 0;
11720 wxLogGui *result = 0 ;
11721
11722 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11723 {
11724 PyThreadState* __tstate = wxPyBeginAllowThreads();
11725 result = (wxLogGui *)new wxLogGui();
11726 wxPyEndAllowThreads(__tstate);
11727 if (PyErr_Occurred()) SWIG_fail;
11728 }
11729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11730 return resultobj;
11731 fail:
11732 return NULL;
11733 }
11734
11735
11736 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11737 PyObject *obj;
11738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11739 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11740 return SWIG_Py_Void();
11741 }
11742
11743 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11744 return SWIG_Python_InitShadowInstance(args);
11745 }
11746
11747 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11748 PyObject *resultobj = 0;
11749 wxFrame *arg1 = (wxFrame *) 0 ;
11750 wxString *arg2 = 0 ;
11751 bool arg3 = (bool) true ;
11752 bool arg4 = (bool) true ;
11753 wxLogWindow *result = 0 ;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 bool temp2 = false ;
11757 bool val3 ;
11758 int ecode3 = 0 ;
11759 bool val4 ;
11760 int ecode4 = 0 ;
11761 PyObject * obj0 = 0 ;
11762 PyObject * obj1 = 0 ;
11763 PyObject * obj2 = 0 ;
11764 PyObject * obj3 = 0 ;
11765 char * kwnames[] = {
11766 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11767 };
11768
11769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11771 if (!SWIG_IsOK(res1)) {
11772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11773 }
11774 arg1 = reinterpret_cast< wxFrame * >(argp1);
11775 {
11776 arg2 = wxString_in_helper(obj1);
11777 if (arg2 == NULL) SWIG_fail;
11778 temp2 = true;
11779 }
11780 if (obj2) {
11781 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11782 if (!SWIG_IsOK(ecode3)) {
11783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11784 }
11785 arg3 = static_cast< bool >(val3);
11786 }
11787 if (obj3) {
11788 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11789 if (!SWIG_IsOK(ecode4)) {
11790 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11791 }
11792 arg4 = static_cast< bool >(val4);
11793 }
11794 {
11795 PyThreadState* __tstate = wxPyBeginAllowThreads();
11796 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11797 wxPyEndAllowThreads(__tstate);
11798 if (PyErr_Occurred()) SWIG_fail;
11799 }
11800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11801 {
11802 if (temp2)
11803 delete arg2;
11804 }
11805 return resultobj;
11806 fail:
11807 {
11808 if (temp2)
11809 delete arg2;
11810 }
11811 return NULL;
11812 }
11813
11814
11815 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11816 PyObject *resultobj = 0;
11817 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11818 bool arg2 = (bool) true ;
11819 void *argp1 = 0 ;
11820 int res1 = 0 ;
11821 bool val2 ;
11822 int ecode2 = 0 ;
11823 PyObject * obj0 = 0 ;
11824 PyObject * obj1 = 0 ;
11825 char * kwnames[] = {
11826 (char *) "self",(char *) "bShow", NULL
11827 };
11828
11829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11831 if (!SWIG_IsOK(res1)) {
11832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11833 }
11834 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11835 if (obj1) {
11836 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11837 if (!SWIG_IsOK(ecode2)) {
11838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11839 }
11840 arg2 = static_cast< bool >(val2);
11841 }
11842 {
11843 PyThreadState* __tstate = wxPyBeginAllowThreads();
11844 (arg1)->Show(arg2);
11845 wxPyEndAllowThreads(__tstate);
11846 if (PyErr_Occurred()) SWIG_fail;
11847 }
11848 resultobj = SWIG_Py_Void();
11849 return resultobj;
11850 fail:
11851 return NULL;
11852 }
11853
11854
11855 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11856 PyObject *resultobj = 0;
11857 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11858 wxFrame *result = 0 ;
11859 void *argp1 = 0 ;
11860 int res1 = 0 ;
11861 PyObject *swig_obj[1] ;
11862
11863 if (!args) SWIG_fail;
11864 swig_obj[0] = args;
11865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11866 if (!SWIG_IsOK(res1)) {
11867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11868 }
11869 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11870 {
11871 PyThreadState* __tstate = wxPyBeginAllowThreads();
11872 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11873 wxPyEndAllowThreads(__tstate);
11874 if (PyErr_Occurred()) SWIG_fail;
11875 }
11876 {
11877 resultobj = wxPyMake_wxObject(result, (bool)0);
11878 }
11879 return resultobj;
11880 fail:
11881 return NULL;
11882 }
11883
11884
11885 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11886 PyObject *resultobj = 0;
11887 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11888 wxLog *result = 0 ;
11889 void *argp1 = 0 ;
11890 int res1 = 0 ;
11891 PyObject *swig_obj[1] ;
11892
11893 if (!args) SWIG_fail;
11894 swig_obj[0] = args;
11895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11896 if (!SWIG_IsOK(res1)) {
11897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11898 }
11899 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11900 {
11901 PyThreadState* __tstate = wxPyBeginAllowThreads();
11902 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11903 wxPyEndAllowThreads(__tstate);
11904 if (PyErr_Occurred()) SWIG_fail;
11905 }
11906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11907 return resultobj;
11908 fail:
11909 return NULL;
11910 }
11911
11912
11913 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11914 PyObject *resultobj = 0;
11915 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11916 bool result;
11917 void *argp1 = 0 ;
11918 int res1 = 0 ;
11919 PyObject *swig_obj[1] ;
11920
11921 if (!args) SWIG_fail;
11922 swig_obj[0] = args;
11923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11924 if (!SWIG_IsOK(res1)) {
11925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11926 }
11927 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11928 {
11929 PyThreadState* __tstate = wxPyBeginAllowThreads();
11930 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 {
11935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11936 }
11937 return resultobj;
11938 fail:
11939 return NULL;
11940 }
11941
11942
11943 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11944 PyObject *resultobj = 0;
11945 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11946 bool arg2 ;
11947 void *argp1 = 0 ;
11948 int res1 = 0 ;
11949 bool val2 ;
11950 int ecode2 = 0 ;
11951 PyObject * obj0 = 0 ;
11952 PyObject * obj1 = 0 ;
11953 char * kwnames[] = {
11954 (char *) "self",(char *) "bDoPass", NULL
11955 };
11956
11957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11959 if (!SWIG_IsOK(res1)) {
11960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11961 }
11962 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11963 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11964 if (!SWIG_IsOK(ecode2)) {
11965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11966 }
11967 arg2 = static_cast< bool >(val2);
11968 {
11969 PyThreadState* __tstate = wxPyBeginAllowThreads();
11970 (arg1)->PassMessages(arg2);
11971 wxPyEndAllowThreads(__tstate);
11972 if (PyErr_Occurred()) SWIG_fail;
11973 }
11974 resultobj = SWIG_Py_Void();
11975 return resultobj;
11976 fail:
11977 return NULL;
11978 }
11979
11980
11981 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11982 PyObject *obj;
11983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11984 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11985 return SWIG_Py_Void();
11986 }
11987
11988 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11989 return SWIG_Python_InitShadowInstance(args);
11990 }
11991
11992 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11993 PyObject *resultobj = 0;
11994 wxLog *arg1 = (wxLog *) 0 ;
11995 wxLogChain *result = 0 ;
11996 void *argp1 = 0 ;
11997 int res1 = 0 ;
11998 PyObject * obj0 = 0 ;
11999 char * kwnames[] = {
12000 (char *) "logger", NULL
12001 };
12002
12003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12005 if (!SWIG_IsOK(res1)) {
12006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12007 }
12008 arg1 = reinterpret_cast< wxLog * >(argp1);
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 result = (wxLogChain *)new wxLogChain(arg1);
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12016 return resultobj;
12017 fail:
12018 return NULL;
12019 }
12020
12021
12022 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12023 PyObject *resultobj = 0;
12024 wxLogChain *arg1 = (wxLogChain *) 0 ;
12025 wxLog *arg2 = (wxLog *) 0 ;
12026 void *argp1 = 0 ;
12027 int res1 = 0 ;
12028 void *argp2 = 0 ;
12029 int res2 = 0 ;
12030 PyObject * obj0 = 0 ;
12031 PyObject * obj1 = 0 ;
12032 char * kwnames[] = {
12033 (char *) "self",(char *) "logger", NULL
12034 };
12035
12036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12038 if (!SWIG_IsOK(res1)) {
12039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12040 }
12041 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12043 if (!SWIG_IsOK(res2)) {
12044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12045 }
12046 arg2 = reinterpret_cast< wxLog * >(argp2);
12047 {
12048 PyThreadState* __tstate = wxPyBeginAllowThreads();
12049 (arg1)->SetLog(arg2);
12050 wxPyEndAllowThreads(__tstate);
12051 if (PyErr_Occurred()) SWIG_fail;
12052 }
12053 resultobj = SWIG_Py_Void();
12054 return resultobj;
12055 fail:
12056 return NULL;
12057 }
12058
12059
12060 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12061 PyObject *resultobj = 0;
12062 wxLogChain *arg1 = (wxLogChain *) 0 ;
12063 bool arg2 ;
12064 void *argp1 = 0 ;
12065 int res1 = 0 ;
12066 bool val2 ;
12067 int ecode2 = 0 ;
12068 PyObject * obj0 = 0 ;
12069 PyObject * obj1 = 0 ;
12070 char * kwnames[] = {
12071 (char *) "self",(char *) "bDoPass", NULL
12072 };
12073
12074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12076 if (!SWIG_IsOK(res1)) {
12077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12078 }
12079 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12080 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12081 if (!SWIG_IsOK(ecode2)) {
12082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12083 }
12084 arg2 = static_cast< bool >(val2);
12085 {
12086 PyThreadState* __tstate = wxPyBeginAllowThreads();
12087 (arg1)->PassMessages(arg2);
12088 wxPyEndAllowThreads(__tstate);
12089 if (PyErr_Occurred()) SWIG_fail;
12090 }
12091 resultobj = SWIG_Py_Void();
12092 return resultobj;
12093 fail:
12094 return NULL;
12095 }
12096
12097
12098 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12099 PyObject *resultobj = 0;
12100 wxLogChain *arg1 = (wxLogChain *) 0 ;
12101 bool result;
12102 void *argp1 = 0 ;
12103 int res1 = 0 ;
12104 PyObject *swig_obj[1] ;
12105
12106 if (!args) SWIG_fail;
12107 swig_obj[0] = args;
12108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12109 if (!SWIG_IsOK(res1)) {
12110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12111 }
12112 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12113 {
12114 PyThreadState* __tstate = wxPyBeginAllowThreads();
12115 result = (bool)(arg1)->IsPassingMessages();
12116 wxPyEndAllowThreads(__tstate);
12117 if (PyErr_Occurred()) SWIG_fail;
12118 }
12119 {
12120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12121 }
12122 return resultobj;
12123 fail:
12124 return NULL;
12125 }
12126
12127
12128 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12129 PyObject *resultobj = 0;
12130 wxLogChain *arg1 = (wxLogChain *) 0 ;
12131 wxLog *result = 0 ;
12132 void *argp1 = 0 ;
12133 int res1 = 0 ;
12134 PyObject *swig_obj[1] ;
12135
12136 if (!args) SWIG_fail;
12137 swig_obj[0] = args;
12138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12139 if (!SWIG_IsOK(res1)) {
12140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12141 }
12142 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12143 {
12144 PyThreadState* __tstate = wxPyBeginAllowThreads();
12145 result = (wxLog *)(arg1)->GetOldLog();
12146 wxPyEndAllowThreads(__tstate);
12147 if (PyErr_Occurred()) SWIG_fail;
12148 }
12149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12150 return resultobj;
12151 fail:
12152 return NULL;
12153 }
12154
12155
12156 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12157 PyObject *obj;
12158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12159 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12160 return SWIG_Py_Void();
12161 }
12162
12163 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12164 return SWIG_Python_InitShadowInstance(args);
12165 }
12166
12167 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12168 PyObject *resultobj = 0;
12169 wxLogBuffer *result = 0 ;
12170
12171 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12172 {
12173 PyThreadState* __tstate = wxPyBeginAllowThreads();
12174 result = (wxLogBuffer *)new wxLogBuffer();
12175 wxPyEndAllowThreads(__tstate);
12176 if (PyErr_Occurred()) SWIG_fail;
12177 }
12178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12179 return resultobj;
12180 fail:
12181 return NULL;
12182 }
12183
12184
12185 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12186 PyObject *resultobj = 0;
12187 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12188 wxString *result = 0 ;
12189 void *argp1 = 0 ;
12190 int res1 = 0 ;
12191 PyObject *swig_obj[1] ;
12192
12193 if (!args) SWIG_fail;
12194 swig_obj[0] = args;
12195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12196 if (!SWIG_IsOK(res1)) {
12197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12198 }
12199 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12200 {
12201 PyThreadState* __tstate = wxPyBeginAllowThreads();
12202 {
12203 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12204 result = (wxString *) &_result_ref;
12205 }
12206 wxPyEndAllowThreads(__tstate);
12207 if (PyErr_Occurred()) SWIG_fail;
12208 }
12209 {
12210 #if wxUSE_UNICODE
12211 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12212 #else
12213 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12214 #endif
12215 }
12216 return resultobj;
12217 fail:
12218 return NULL;
12219 }
12220
12221
12222 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12223 PyObject *obj;
12224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12225 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12226 return SWIG_Py_Void();
12227 }
12228
12229 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12230 return SWIG_Python_InitShadowInstance(args);
12231 }
12232
12233 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12234 PyObject *resultobj = 0;
12235 unsigned long result;
12236
12237 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12238 {
12239 PyThreadState* __tstate = wxPyBeginAllowThreads();
12240 result = (unsigned long)wxSysErrorCode();
12241 wxPyEndAllowThreads(__tstate);
12242 if (PyErr_Occurred()) SWIG_fail;
12243 }
12244 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12245 return resultobj;
12246 fail:
12247 return NULL;
12248 }
12249
12250
12251 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12252 PyObject *resultobj = 0;
12253 unsigned long arg1 = (unsigned long) 0 ;
12254 wxString result;
12255 unsigned long val1 ;
12256 int ecode1 = 0 ;
12257 PyObject * obj0 = 0 ;
12258 char * kwnames[] = {
12259 (char *) "nErrCode", NULL
12260 };
12261
12262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12263 if (obj0) {
12264 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12265 if (!SWIG_IsOK(ecode1)) {
12266 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12267 }
12268 arg1 = static_cast< unsigned long >(val1);
12269 }
12270 {
12271 PyThreadState* __tstate = wxPyBeginAllowThreads();
12272 result = wxSysErrorMsg(arg1);
12273 wxPyEndAllowThreads(__tstate);
12274 if (PyErr_Occurred()) SWIG_fail;
12275 }
12276 {
12277 #if wxUSE_UNICODE
12278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12279 #else
12280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12281 #endif
12282 }
12283 return resultobj;
12284 fail:
12285 return NULL;
12286 }
12287
12288
12289 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj = 0;
12291 wxString *arg1 = 0 ;
12292 bool temp1 = false ;
12293 PyObject * obj0 = 0 ;
12294 char * kwnames[] = {
12295 (char *) "msg", NULL
12296 };
12297
12298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12299 {
12300 arg1 = wxString_in_helper(obj0);
12301 if (arg1 == NULL) SWIG_fail;
12302 temp1 = true;
12303 }
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 wxPyLogFatalError((wxString const &)*arg1);
12307 wxPyEndAllowThreads(__tstate);
12308 if (PyErr_Occurred()) SWIG_fail;
12309 }
12310 resultobj = SWIG_Py_Void();
12311 {
12312 if (temp1)
12313 delete arg1;
12314 }
12315 return resultobj;
12316 fail:
12317 {
12318 if (temp1)
12319 delete arg1;
12320 }
12321 return NULL;
12322 }
12323
12324
12325 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12326 PyObject *resultobj = 0;
12327 wxString *arg1 = 0 ;
12328 bool temp1 = false ;
12329 PyObject * obj0 = 0 ;
12330 char * kwnames[] = {
12331 (char *) "msg", NULL
12332 };
12333
12334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12335 {
12336 arg1 = wxString_in_helper(obj0);
12337 if (arg1 == NULL) SWIG_fail;
12338 temp1 = true;
12339 }
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 wxPyLogError((wxString const &)*arg1);
12343 wxPyEndAllowThreads(__tstate);
12344 if (PyErr_Occurred()) SWIG_fail;
12345 }
12346 resultobj = SWIG_Py_Void();
12347 {
12348 if (temp1)
12349 delete arg1;
12350 }
12351 return resultobj;
12352 fail:
12353 {
12354 if (temp1)
12355 delete arg1;
12356 }
12357 return NULL;
12358 }
12359
12360
12361 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12362 PyObject *resultobj = 0;
12363 wxString *arg1 = 0 ;
12364 bool temp1 = false ;
12365 PyObject * obj0 = 0 ;
12366 char * kwnames[] = {
12367 (char *) "msg", NULL
12368 };
12369
12370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12371 {
12372 arg1 = wxString_in_helper(obj0);
12373 if (arg1 == NULL) SWIG_fail;
12374 temp1 = true;
12375 }
12376 {
12377 PyThreadState* __tstate = wxPyBeginAllowThreads();
12378 wxPyLogWarning((wxString const &)*arg1);
12379 wxPyEndAllowThreads(__tstate);
12380 if (PyErr_Occurred()) SWIG_fail;
12381 }
12382 resultobj = SWIG_Py_Void();
12383 {
12384 if (temp1)
12385 delete arg1;
12386 }
12387 return resultobj;
12388 fail:
12389 {
12390 if (temp1)
12391 delete arg1;
12392 }
12393 return NULL;
12394 }
12395
12396
12397 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12398 PyObject *resultobj = 0;
12399 wxString *arg1 = 0 ;
12400 bool temp1 = false ;
12401 PyObject * obj0 = 0 ;
12402 char * kwnames[] = {
12403 (char *) "msg", NULL
12404 };
12405
12406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12407 {
12408 arg1 = wxString_in_helper(obj0);
12409 if (arg1 == NULL) SWIG_fail;
12410 temp1 = true;
12411 }
12412 {
12413 PyThreadState* __tstate = wxPyBeginAllowThreads();
12414 wxPyLogMessage((wxString const &)*arg1);
12415 wxPyEndAllowThreads(__tstate);
12416 if (PyErr_Occurred()) SWIG_fail;
12417 }
12418 resultobj = SWIG_Py_Void();
12419 {
12420 if (temp1)
12421 delete arg1;
12422 }
12423 return resultobj;
12424 fail:
12425 {
12426 if (temp1)
12427 delete arg1;
12428 }
12429 return NULL;
12430 }
12431
12432
12433 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12434 PyObject *resultobj = 0;
12435 wxString *arg1 = 0 ;
12436 bool temp1 = false ;
12437 PyObject * obj0 = 0 ;
12438 char * kwnames[] = {
12439 (char *) "msg", NULL
12440 };
12441
12442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12443 {
12444 arg1 = wxString_in_helper(obj0);
12445 if (arg1 == NULL) SWIG_fail;
12446 temp1 = true;
12447 }
12448 {
12449 PyThreadState* __tstate = wxPyBeginAllowThreads();
12450 wxPyLogInfo((wxString const &)*arg1);
12451 wxPyEndAllowThreads(__tstate);
12452 if (PyErr_Occurred()) SWIG_fail;
12453 }
12454 resultobj = SWIG_Py_Void();
12455 {
12456 if (temp1)
12457 delete arg1;
12458 }
12459 return resultobj;
12460 fail:
12461 {
12462 if (temp1)
12463 delete arg1;
12464 }
12465 return NULL;
12466 }
12467
12468
12469 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12470 PyObject *resultobj = 0;
12471 wxString *arg1 = 0 ;
12472 bool temp1 = false ;
12473 PyObject * obj0 = 0 ;
12474 char * kwnames[] = {
12475 (char *) "msg", NULL
12476 };
12477
12478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12479 {
12480 arg1 = wxString_in_helper(obj0);
12481 if (arg1 == NULL) SWIG_fail;
12482 temp1 = true;
12483 }
12484 {
12485 PyThreadState* __tstate = wxPyBeginAllowThreads();
12486 wxPyLogDebug((wxString const &)*arg1);
12487 wxPyEndAllowThreads(__tstate);
12488 if (PyErr_Occurred()) SWIG_fail;
12489 }
12490 resultobj = SWIG_Py_Void();
12491 {
12492 if (temp1)
12493 delete arg1;
12494 }
12495 return resultobj;
12496 fail:
12497 {
12498 if (temp1)
12499 delete arg1;
12500 }
12501 return NULL;
12502 }
12503
12504
12505 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12506 PyObject *resultobj = 0;
12507 wxString *arg1 = 0 ;
12508 bool temp1 = false ;
12509 PyObject * obj0 = 0 ;
12510 char * kwnames[] = {
12511 (char *) "msg", NULL
12512 };
12513
12514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12515 {
12516 arg1 = wxString_in_helper(obj0);
12517 if (arg1 == NULL) SWIG_fail;
12518 temp1 = true;
12519 }
12520 {
12521 PyThreadState* __tstate = wxPyBeginAllowThreads();
12522 wxPyLogVerbose((wxString const &)*arg1);
12523 wxPyEndAllowThreads(__tstate);
12524 if (PyErr_Occurred()) SWIG_fail;
12525 }
12526 resultobj = SWIG_Py_Void();
12527 {
12528 if (temp1)
12529 delete arg1;
12530 }
12531 return resultobj;
12532 fail:
12533 {
12534 if (temp1)
12535 delete arg1;
12536 }
12537 return NULL;
12538 }
12539
12540
12541 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12542 PyObject *resultobj = 0;
12543 wxString *arg1 = 0 ;
12544 bool temp1 = false ;
12545 PyObject * obj0 = 0 ;
12546 char * kwnames[] = {
12547 (char *) "msg", NULL
12548 };
12549
12550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12551 {
12552 arg1 = wxString_in_helper(obj0);
12553 if (arg1 == NULL) SWIG_fail;
12554 temp1 = true;
12555 }
12556 {
12557 PyThreadState* __tstate = wxPyBeginAllowThreads();
12558 wxPyLogStatus((wxString const &)*arg1);
12559 wxPyEndAllowThreads(__tstate);
12560 if (PyErr_Occurred()) SWIG_fail;
12561 }
12562 resultobj = SWIG_Py_Void();
12563 {
12564 if (temp1)
12565 delete arg1;
12566 }
12567 return resultobj;
12568 fail:
12569 {
12570 if (temp1)
12571 delete arg1;
12572 }
12573 return NULL;
12574 }
12575
12576
12577 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12578 PyObject *resultobj = 0;
12579 wxFrame *arg1 = (wxFrame *) 0 ;
12580 wxString *arg2 = 0 ;
12581 void *argp1 = 0 ;
12582 int res1 = 0 ;
12583 bool temp2 = false ;
12584 PyObject * obj0 = 0 ;
12585 PyObject * obj1 = 0 ;
12586 char * kwnames[] = {
12587 (char *) "pFrame",(char *) "msg", NULL
12588 };
12589
12590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12592 if (!SWIG_IsOK(res1)) {
12593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12594 }
12595 arg1 = reinterpret_cast< wxFrame * >(argp1);
12596 {
12597 arg2 = wxString_in_helper(obj1);
12598 if (arg2 == NULL) SWIG_fail;
12599 temp2 = true;
12600 }
12601 {
12602 PyThreadState* __tstate = wxPyBeginAllowThreads();
12603 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12604 wxPyEndAllowThreads(__tstate);
12605 if (PyErr_Occurred()) SWIG_fail;
12606 }
12607 resultobj = SWIG_Py_Void();
12608 {
12609 if (temp2)
12610 delete arg2;
12611 }
12612 return resultobj;
12613 fail:
12614 {
12615 if (temp2)
12616 delete arg2;
12617 }
12618 return NULL;
12619 }
12620
12621
12622 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12623 PyObject *resultobj = 0;
12624 wxString *arg1 = 0 ;
12625 bool temp1 = false ;
12626 PyObject * obj0 = 0 ;
12627 char * kwnames[] = {
12628 (char *) "msg", NULL
12629 };
12630
12631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12632 {
12633 arg1 = wxString_in_helper(obj0);
12634 if (arg1 == NULL) SWIG_fail;
12635 temp1 = true;
12636 }
12637 {
12638 PyThreadState* __tstate = wxPyBeginAllowThreads();
12639 wxPyLogSysError((wxString const &)*arg1);
12640 wxPyEndAllowThreads(__tstate);
12641 if (PyErr_Occurred()) SWIG_fail;
12642 }
12643 resultobj = SWIG_Py_Void();
12644 {
12645 if (temp1)
12646 delete arg1;
12647 }
12648 return resultobj;
12649 fail:
12650 {
12651 if (temp1)
12652 delete arg1;
12653 }
12654 return NULL;
12655 }
12656
12657
12658 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12659 PyObject *resultobj = 0;
12660 unsigned long arg1 ;
12661 wxString *arg2 = 0 ;
12662 unsigned long val1 ;
12663 int ecode1 = 0 ;
12664 bool temp2 = false ;
12665 PyObject * obj0 = 0 ;
12666 PyObject * obj1 = 0 ;
12667 char * kwnames[] = {
12668 (char *) "level",(char *) "msg", NULL
12669 };
12670
12671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12672 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12673 if (!SWIG_IsOK(ecode1)) {
12674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12675 }
12676 arg1 = static_cast< unsigned long >(val1);
12677 {
12678 arg2 = wxString_in_helper(obj1);
12679 if (arg2 == NULL) SWIG_fail;
12680 temp2 = true;
12681 }
12682 {
12683 PyThreadState* __tstate = wxPyBeginAllowThreads();
12684 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12685 wxPyEndAllowThreads(__tstate);
12686 if (PyErr_Occurred()) SWIG_fail;
12687 }
12688 resultobj = SWIG_Py_Void();
12689 {
12690 if (temp2)
12691 delete arg2;
12692 }
12693 return resultobj;
12694 fail:
12695 {
12696 if (temp2)
12697 delete arg2;
12698 }
12699 return NULL;
12700 }
12701
12702
12703 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12704 PyObject *resultobj = 0;
12705 unsigned long arg1 ;
12706 wxString *arg2 = 0 ;
12707 unsigned long val1 ;
12708 int ecode1 = 0 ;
12709 bool temp2 = false ;
12710
12711 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12712 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12713 if (!SWIG_IsOK(ecode1)) {
12714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12715 }
12716 arg1 = static_cast< unsigned long >(val1);
12717 {
12718 arg2 = wxString_in_helper(swig_obj[1]);
12719 if (arg2 == NULL) SWIG_fail;
12720 temp2 = true;
12721 }
12722 {
12723 PyThreadState* __tstate = wxPyBeginAllowThreads();
12724 wxPyLogTrace(arg1,(wxString const &)*arg2);
12725 wxPyEndAllowThreads(__tstate);
12726 if (PyErr_Occurred()) SWIG_fail;
12727 }
12728 resultobj = SWIG_Py_Void();
12729 {
12730 if (temp2)
12731 delete arg2;
12732 }
12733 return resultobj;
12734 fail:
12735 {
12736 if (temp2)
12737 delete arg2;
12738 }
12739 return NULL;
12740 }
12741
12742
12743 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12744 PyObject *resultobj = 0;
12745 wxString *arg1 = 0 ;
12746 wxString *arg2 = 0 ;
12747 bool temp1 = false ;
12748 bool temp2 = false ;
12749
12750 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12751 {
12752 arg1 = wxString_in_helper(swig_obj[0]);
12753 if (arg1 == NULL) SWIG_fail;
12754 temp1 = true;
12755 }
12756 {
12757 arg2 = wxString_in_helper(swig_obj[1]);
12758 if (arg2 == NULL) SWIG_fail;
12759 temp2 = true;
12760 }
12761 {
12762 PyThreadState* __tstate = wxPyBeginAllowThreads();
12763 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12764 wxPyEndAllowThreads(__tstate);
12765 if (PyErr_Occurred()) SWIG_fail;
12766 }
12767 resultobj = SWIG_Py_Void();
12768 {
12769 if (temp1)
12770 delete arg1;
12771 }
12772 {
12773 if (temp2)
12774 delete arg2;
12775 }
12776 return resultobj;
12777 fail:
12778 {
12779 if (temp1)
12780 delete arg1;
12781 }
12782 {
12783 if (temp2)
12784 delete arg2;
12785 }
12786 return NULL;
12787 }
12788
12789
12790 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12791 int argc;
12792 PyObject *argv[3];
12793
12794 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12795 --argc;
12796 if (argc == 2) {
12797 int _v = 0;
12798 {
12799 {
12800 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12801 }
12802 }
12803 if (!_v) goto check_1;
12804 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12805 }
12806 check_1:
12807
12808 if (argc == 2) {
12809 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12810 }
12811
12812 fail:
12813 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12814 return NULL;
12815 }
12816
12817
12818 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12819 PyObject *resultobj = 0;
12820 wxString *arg1 = 0 ;
12821 wxString *arg2 = 0 ;
12822 bool temp1 = false ;
12823 bool temp2 = false ;
12824 PyObject * obj0 = 0 ;
12825 PyObject * obj1 = 0 ;
12826 char * kwnames[] = {
12827 (char *) "title",(char *) "text", NULL
12828 };
12829
12830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12831 {
12832 arg1 = wxString_in_helper(obj0);
12833 if (arg1 == NULL) SWIG_fail;
12834 temp1 = true;
12835 }
12836 {
12837 arg2 = wxString_in_helper(obj1);
12838 if (arg2 == NULL) SWIG_fail;
12839 temp2 = true;
12840 }
12841 {
12842 PyThreadState* __tstate = wxPyBeginAllowThreads();
12843 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12844 wxPyEndAllowThreads(__tstate);
12845 if (PyErr_Occurred()) SWIG_fail;
12846 }
12847 resultobj = SWIG_Py_Void();
12848 {
12849 if (temp1)
12850 delete arg1;
12851 }
12852 {
12853 if (temp2)
12854 delete arg2;
12855 }
12856 return resultobj;
12857 fail:
12858 {
12859 if (temp1)
12860 delete arg1;
12861 }
12862 {
12863 if (temp2)
12864 delete arg2;
12865 }
12866 return NULL;
12867 }
12868
12869
12870 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12871 PyObject *resultobj = 0;
12872 wxLogNull *result = 0 ;
12873
12874 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12875 {
12876 PyThreadState* __tstate = wxPyBeginAllowThreads();
12877 result = (wxLogNull *)new wxLogNull();
12878 wxPyEndAllowThreads(__tstate);
12879 if (PyErr_Occurred()) SWIG_fail;
12880 }
12881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12882 return resultobj;
12883 fail:
12884 return NULL;
12885 }
12886
12887
12888 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12889 PyObject *resultobj = 0;
12890 wxLogNull *arg1 = (wxLogNull *) 0 ;
12891 void *argp1 = 0 ;
12892 int res1 = 0 ;
12893 PyObject *swig_obj[1] ;
12894
12895 if (!args) SWIG_fail;
12896 swig_obj[0] = args;
12897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12898 if (!SWIG_IsOK(res1)) {
12899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12900 }
12901 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12902 {
12903 PyThreadState* __tstate = wxPyBeginAllowThreads();
12904 delete arg1;
12905
12906 wxPyEndAllowThreads(__tstate);
12907 if (PyErr_Occurred()) SWIG_fail;
12908 }
12909 resultobj = SWIG_Py_Void();
12910 return resultobj;
12911 fail:
12912 return NULL;
12913 }
12914
12915
12916 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12917 PyObject *obj;
12918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12919 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12920 return SWIG_Py_Void();
12921 }
12922
12923 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12924 return SWIG_Python_InitShadowInstance(args);
12925 }
12926
12927 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928 PyObject *resultobj = 0;
12929 wxPyLog *result = 0 ;
12930
12931 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12932 {
12933 PyThreadState* __tstate = wxPyBeginAllowThreads();
12934 result = (wxPyLog *)new wxPyLog();
12935 wxPyEndAllowThreads(__tstate);
12936 if (PyErr_Occurred()) SWIG_fail;
12937 }
12938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12939 return resultobj;
12940 fail:
12941 return NULL;
12942 }
12943
12944
12945 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12946 PyObject *resultobj = 0;
12947 wxPyLog *arg1 = (wxPyLog *) 0 ;
12948 PyObject *arg2 = (PyObject *) 0 ;
12949 PyObject *arg3 = (PyObject *) 0 ;
12950 void *argp1 = 0 ;
12951 int res1 = 0 ;
12952 PyObject * obj0 = 0 ;
12953 PyObject * obj1 = 0 ;
12954 PyObject * obj2 = 0 ;
12955 char * kwnames[] = {
12956 (char *) "self",(char *) "self",(char *) "_class", NULL
12957 };
12958
12959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12961 if (!SWIG_IsOK(res1)) {
12962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12963 }
12964 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12965 arg2 = obj1;
12966 arg3 = obj2;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 (arg1)->_setCallbackInfo(arg2,arg3);
12970 wxPyEndAllowThreads(__tstate);
12971 if (PyErr_Occurred()) SWIG_fail;
12972 }
12973 resultobj = SWIG_Py_Void();
12974 return resultobj;
12975 fail:
12976 return NULL;
12977 }
12978
12979
12980 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12981 PyObject *obj;
12982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12983 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12984 return SWIG_Py_Void();
12985 }
12986
12987 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12988 return SWIG_Python_InitShadowInstance(args);
12989 }
12990
12991 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12992 PyObject *resultobj = 0;
12993 int arg1 ;
12994 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12995 int arg3 = (int) wxKILL_NOCHILDREN ;
12996 wxKillError result;
12997 int val1 ;
12998 int ecode1 = 0 ;
12999 int val2 ;
13000 int ecode2 = 0 ;
13001 int val3 ;
13002 int ecode3 = 0 ;
13003 PyObject * obj0 = 0 ;
13004 PyObject * obj1 = 0 ;
13005 PyObject * obj2 = 0 ;
13006 char * kwnames[] = {
13007 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13008 };
13009
13010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13011 ecode1 = SWIG_AsVal_int(obj0, &val1);
13012 if (!SWIG_IsOK(ecode1)) {
13013 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13014 }
13015 arg1 = static_cast< int >(val1);
13016 if (obj1) {
13017 ecode2 = SWIG_AsVal_int(obj1, &val2);
13018 if (!SWIG_IsOK(ecode2)) {
13019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13020 }
13021 arg2 = static_cast< wxSignal >(val2);
13022 }
13023 if (obj2) {
13024 ecode3 = SWIG_AsVal_int(obj2, &val3);
13025 if (!SWIG_IsOK(ecode3)) {
13026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13027 }
13028 arg3 = static_cast< int >(val3);
13029 }
13030 {
13031 PyThreadState* __tstate = wxPyBeginAllowThreads();
13032 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13033 wxPyEndAllowThreads(__tstate);
13034 if (PyErr_Occurred()) SWIG_fail;
13035 }
13036 resultobj = SWIG_From_int(static_cast< int >(result));
13037 return resultobj;
13038 fail:
13039 return NULL;
13040 }
13041
13042
13043 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13044 PyObject *resultobj = 0;
13045 int arg1 ;
13046 bool result;
13047 int val1 ;
13048 int ecode1 = 0 ;
13049 PyObject * obj0 = 0 ;
13050 char * kwnames[] = {
13051 (char *) "pid", NULL
13052 };
13053
13054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13055 ecode1 = SWIG_AsVal_int(obj0, &val1);
13056 if (!SWIG_IsOK(ecode1)) {
13057 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13058 }
13059 arg1 = static_cast< int >(val1);
13060 {
13061 PyThreadState* __tstate = wxPyBeginAllowThreads();
13062 result = (bool)wxPyProcess::Exists(arg1);
13063 wxPyEndAllowThreads(__tstate);
13064 if (PyErr_Occurred()) SWIG_fail;
13065 }
13066 {
13067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13068 }
13069 return resultobj;
13070 fail:
13071 return NULL;
13072 }
13073
13074
13075 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13076 PyObject *resultobj = 0;
13077 wxString *arg1 = 0 ;
13078 int arg2 = (int) wxEXEC_ASYNC ;
13079 wxPyProcess *result = 0 ;
13080 bool temp1 = false ;
13081 int val2 ;
13082 int ecode2 = 0 ;
13083 PyObject * obj0 = 0 ;
13084 PyObject * obj1 = 0 ;
13085 char * kwnames[] = {
13086 (char *) "cmd",(char *) "flags", NULL
13087 };
13088
13089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13090 {
13091 arg1 = wxString_in_helper(obj0);
13092 if (arg1 == NULL) SWIG_fail;
13093 temp1 = true;
13094 }
13095 if (obj1) {
13096 ecode2 = SWIG_AsVal_int(obj1, &val2);
13097 if (!SWIG_IsOK(ecode2)) {
13098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13099 }
13100 arg2 = static_cast< int >(val2);
13101 }
13102 {
13103 PyThreadState* __tstate = wxPyBeginAllowThreads();
13104 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13105 wxPyEndAllowThreads(__tstate);
13106 if (PyErr_Occurred()) SWIG_fail;
13107 }
13108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13109 {
13110 if (temp1)
13111 delete arg1;
13112 }
13113 return resultobj;
13114 fail:
13115 {
13116 if (temp1)
13117 delete arg1;
13118 }
13119 return NULL;
13120 }
13121
13122
13123 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13124 PyObject *resultobj = 0;
13125 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13126 int arg2 = (int) -1 ;
13127 wxPyProcess *result = 0 ;
13128 void *argp1 = 0 ;
13129 int res1 = 0 ;
13130 int val2 ;
13131 int ecode2 = 0 ;
13132 PyObject * obj0 = 0 ;
13133 PyObject * obj1 = 0 ;
13134 char * kwnames[] = {
13135 (char *) "parent",(char *) "id", NULL
13136 };
13137
13138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13139 if (obj0) {
13140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13141 if (!SWIG_IsOK(res1)) {
13142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13143 }
13144 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13145 }
13146 if (obj1) {
13147 ecode2 = SWIG_AsVal_int(obj1, &val2);
13148 if (!SWIG_IsOK(ecode2)) {
13149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13150 }
13151 arg2 = static_cast< int >(val2);
13152 }
13153 {
13154 PyThreadState* __tstate = wxPyBeginAllowThreads();
13155 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13156 wxPyEndAllowThreads(__tstate);
13157 if (PyErr_Occurred()) SWIG_fail;
13158 }
13159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13160 return resultobj;
13161 fail:
13162 return NULL;
13163 }
13164
13165
13166 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13167 PyObject *resultobj = 0;
13168 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13169 PyObject *arg2 = (PyObject *) 0 ;
13170 PyObject *arg3 = (PyObject *) 0 ;
13171 void *argp1 = 0 ;
13172 int res1 = 0 ;
13173 PyObject * obj0 = 0 ;
13174 PyObject * obj1 = 0 ;
13175 PyObject * obj2 = 0 ;
13176 char * kwnames[] = {
13177 (char *) "self",(char *) "self",(char *) "_class", NULL
13178 };
13179
13180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13182 if (!SWIG_IsOK(res1)) {
13183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13184 }
13185 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13186 arg2 = obj1;
13187 arg3 = obj2;
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 (arg1)->_setCallbackInfo(arg2,arg3);
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 resultobj = SWIG_Py_Void();
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13202 PyObject *resultobj = 0;
13203 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13204 int arg2 ;
13205 int arg3 ;
13206 void *argp1 = 0 ;
13207 int res1 = 0 ;
13208 int val2 ;
13209 int ecode2 = 0 ;
13210 int val3 ;
13211 int ecode3 = 0 ;
13212 PyObject * obj0 = 0 ;
13213 PyObject * obj1 = 0 ;
13214 PyObject * obj2 = 0 ;
13215 char * kwnames[] = {
13216 (char *) "self",(char *) "pid",(char *) "status", NULL
13217 };
13218
13219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13221 if (!SWIG_IsOK(res1)) {
13222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13223 }
13224 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13225 ecode2 = SWIG_AsVal_int(obj1, &val2);
13226 if (!SWIG_IsOK(ecode2)) {
13227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13228 }
13229 arg2 = static_cast< int >(val2);
13230 ecode3 = SWIG_AsVal_int(obj2, &val3);
13231 if (!SWIG_IsOK(ecode3)) {
13232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13233 }
13234 arg3 = static_cast< int >(val3);
13235 {
13236 PyThreadState* __tstate = wxPyBeginAllowThreads();
13237 (arg1)->OnTerminate(arg2,arg3);
13238 wxPyEndAllowThreads(__tstate);
13239 if (PyErr_Occurred()) SWIG_fail;
13240 }
13241 resultobj = SWIG_Py_Void();
13242 return resultobj;
13243 fail:
13244 return NULL;
13245 }
13246
13247
13248 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13249 PyObject *resultobj = 0;
13250 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13251 void *argp1 = 0 ;
13252 int res1 = 0 ;
13253 PyObject *swig_obj[1] ;
13254
13255 if (!args) SWIG_fail;
13256 swig_obj[0] = args;
13257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13258 if (!SWIG_IsOK(res1)) {
13259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13260 }
13261 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13262 {
13263 PyThreadState* __tstate = wxPyBeginAllowThreads();
13264 (arg1)->Redirect();
13265 wxPyEndAllowThreads(__tstate);
13266 if (PyErr_Occurred()) SWIG_fail;
13267 }
13268 resultobj = SWIG_Py_Void();
13269 return resultobj;
13270 fail:
13271 return NULL;
13272 }
13273
13274
13275 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13276 PyObject *resultobj = 0;
13277 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13278 bool result;
13279 void *argp1 = 0 ;
13280 int res1 = 0 ;
13281 PyObject *swig_obj[1] ;
13282
13283 if (!args) SWIG_fail;
13284 swig_obj[0] = args;
13285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13286 if (!SWIG_IsOK(res1)) {
13287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13288 }
13289 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13290 {
13291 PyThreadState* __tstate = wxPyBeginAllowThreads();
13292 result = (bool)(arg1)->IsRedirected();
13293 wxPyEndAllowThreads(__tstate);
13294 if (PyErr_Occurred()) SWIG_fail;
13295 }
13296 {
13297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13298 }
13299 return resultobj;
13300 fail:
13301 return NULL;
13302 }
13303
13304
13305 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13306 PyObject *resultobj = 0;
13307 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13308 void *argp1 = 0 ;
13309 int res1 = 0 ;
13310 PyObject *swig_obj[1] ;
13311
13312 if (!args) SWIG_fail;
13313 swig_obj[0] = args;
13314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13315 if (!SWIG_IsOK(res1)) {
13316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13317 }
13318 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13319 {
13320 PyThreadState* __tstate = wxPyBeginAllowThreads();
13321 (arg1)->Detach();
13322 wxPyEndAllowThreads(__tstate);
13323 if (PyErr_Occurred()) SWIG_fail;
13324 }
13325 resultobj = SWIG_Py_Void();
13326 return resultobj;
13327 fail:
13328 return NULL;
13329 }
13330
13331
13332 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13333 PyObject *resultobj = 0;
13334 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13335 wxInputStream *result = 0 ;
13336 void *argp1 = 0 ;
13337 int res1 = 0 ;
13338 PyObject *swig_obj[1] ;
13339
13340 if (!args) SWIG_fail;
13341 swig_obj[0] = args;
13342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13343 if (!SWIG_IsOK(res1)) {
13344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13345 }
13346 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13347 {
13348 PyThreadState* __tstate = wxPyBeginAllowThreads();
13349 result = (wxInputStream *)(arg1)->GetInputStream();
13350 wxPyEndAllowThreads(__tstate);
13351 if (PyErr_Occurred()) SWIG_fail;
13352 }
13353 {
13354 wxPyInputStream * _ptr = NULL;
13355
13356 if (result) {
13357 _ptr = new wxPyInputStream(result);
13358 }
13359 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13360 }
13361 return resultobj;
13362 fail:
13363 return NULL;
13364 }
13365
13366
13367 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13368 PyObject *resultobj = 0;
13369 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13370 wxInputStream *result = 0 ;
13371 void *argp1 = 0 ;
13372 int res1 = 0 ;
13373 PyObject *swig_obj[1] ;
13374
13375 if (!args) SWIG_fail;
13376 swig_obj[0] = args;
13377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13378 if (!SWIG_IsOK(res1)) {
13379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13380 }
13381 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13382 {
13383 PyThreadState* __tstate = wxPyBeginAllowThreads();
13384 result = (wxInputStream *)(arg1)->GetErrorStream();
13385 wxPyEndAllowThreads(__tstate);
13386 if (PyErr_Occurred()) SWIG_fail;
13387 }
13388 {
13389 wxPyInputStream * _ptr = NULL;
13390
13391 if (result) {
13392 _ptr = new wxPyInputStream(result);
13393 }
13394 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13395 }
13396 return resultobj;
13397 fail:
13398 return NULL;
13399 }
13400
13401
13402 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13403 PyObject *resultobj = 0;
13404 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13405 wxOutputStream *result = 0 ;
13406 void *argp1 = 0 ;
13407 int res1 = 0 ;
13408 PyObject *swig_obj[1] ;
13409
13410 if (!args) SWIG_fail;
13411 swig_obj[0] = args;
13412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13413 if (!SWIG_IsOK(res1)) {
13414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13415 }
13416 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13417 {
13418 PyThreadState* __tstate = wxPyBeginAllowThreads();
13419 result = (wxOutputStream *)(arg1)->GetOutputStream();
13420 wxPyEndAllowThreads(__tstate);
13421 if (PyErr_Occurred()) SWIG_fail;
13422 }
13423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13424 return resultobj;
13425 fail:
13426 return NULL;
13427 }
13428
13429
13430 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13431 PyObject *resultobj = 0;
13432 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13433 void *argp1 = 0 ;
13434 int res1 = 0 ;
13435 PyObject *swig_obj[1] ;
13436
13437 if (!args) SWIG_fail;
13438 swig_obj[0] = args;
13439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13440 if (!SWIG_IsOK(res1)) {
13441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13442 }
13443 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13444 {
13445 PyThreadState* __tstate = wxPyBeginAllowThreads();
13446 (arg1)->CloseOutput();
13447 wxPyEndAllowThreads(__tstate);
13448 if (PyErr_Occurred()) SWIG_fail;
13449 }
13450 resultobj = SWIG_Py_Void();
13451 return resultobj;
13452 fail:
13453 return NULL;
13454 }
13455
13456
13457 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13458 PyObject *resultobj = 0;
13459 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13460 bool result;
13461 void *argp1 = 0 ;
13462 int res1 = 0 ;
13463 PyObject *swig_obj[1] ;
13464
13465 if (!args) SWIG_fail;
13466 swig_obj[0] = args;
13467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13468 if (!SWIG_IsOK(res1)) {
13469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13470 }
13471 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13472 {
13473 PyThreadState* __tstate = wxPyBeginAllowThreads();
13474 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 {
13479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13480 }
13481 return resultobj;
13482 fail:
13483 return NULL;
13484 }
13485
13486
13487 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13488 PyObject *resultobj = 0;
13489 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13490 bool result;
13491 void *argp1 = 0 ;
13492 int res1 = 0 ;
13493 PyObject *swig_obj[1] ;
13494
13495 if (!args) SWIG_fail;
13496 swig_obj[0] = args;
13497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13498 if (!SWIG_IsOK(res1)) {
13499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13500 }
13501 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13502 {
13503 PyThreadState* __tstate = wxPyBeginAllowThreads();
13504 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13505 wxPyEndAllowThreads(__tstate);
13506 if (PyErr_Occurred()) SWIG_fail;
13507 }
13508 {
13509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13510 }
13511 return resultobj;
13512 fail:
13513 return NULL;
13514 }
13515
13516
13517 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13518 PyObject *resultobj = 0;
13519 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13520 bool result;
13521 void *argp1 = 0 ;
13522 int res1 = 0 ;
13523 PyObject *swig_obj[1] ;
13524
13525 if (!args) SWIG_fail;
13526 swig_obj[0] = args;
13527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13528 if (!SWIG_IsOK(res1)) {
13529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13530 }
13531 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13532 {
13533 PyThreadState* __tstate = wxPyBeginAllowThreads();
13534 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 {
13539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13540 }
13541 return resultobj;
13542 fail:
13543 return NULL;
13544 }
13545
13546
13547 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13548 PyObject *obj;
13549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13550 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13551 return SWIG_Py_Void();
13552 }
13553
13554 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13555 return SWIG_Python_InitShadowInstance(args);
13556 }
13557
13558 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13559 PyObject *resultobj = 0;
13560 int arg1 = (int) 0 ;
13561 int arg2 = (int) 0 ;
13562 int arg3 = (int) 0 ;
13563 wxProcessEvent *result = 0 ;
13564 int val1 ;
13565 int ecode1 = 0 ;
13566 int val2 ;
13567 int ecode2 = 0 ;
13568 int val3 ;
13569 int ecode3 = 0 ;
13570 PyObject * obj0 = 0 ;
13571 PyObject * obj1 = 0 ;
13572 PyObject * obj2 = 0 ;
13573 char * kwnames[] = {
13574 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13575 };
13576
13577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13578 if (obj0) {
13579 ecode1 = SWIG_AsVal_int(obj0, &val1);
13580 if (!SWIG_IsOK(ecode1)) {
13581 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13582 }
13583 arg1 = static_cast< int >(val1);
13584 }
13585 if (obj1) {
13586 ecode2 = SWIG_AsVal_int(obj1, &val2);
13587 if (!SWIG_IsOK(ecode2)) {
13588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13589 }
13590 arg2 = static_cast< int >(val2);
13591 }
13592 if (obj2) {
13593 ecode3 = SWIG_AsVal_int(obj2, &val3);
13594 if (!SWIG_IsOK(ecode3)) {
13595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13596 }
13597 arg3 = static_cast< int >(val3);
13598 }
13599 {
13600 PyThreadState* __tstate = wxPyBeginAllowThreads();
13601 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13602 wxPyEndAllowThreads(__tstate);
13603 if (PyErr_Occurred()) SWIG_fail;
13604 }
13605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13606 return resultobj;
13607 fail:
13608 return NULL;
13609 }
13610
13611
13612 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13613 PyObject *resultobj = 0;
13614 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13615 int result;
13616 void *argp1 = 0 ;
13617 int res1 = 0 ;
13618 PyObject *swig_obj[1] ;
13619
13620 if (!args) SWIG_fail;
13621 swig_obj[0] = args;
13622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13623 if (!SWIG_IsOK(res1)) {
13624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13625 }
13626 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13627 {
13628 PyThreadState* __tstate = wxPyBeginAllowThreads();
13629 result = (int)(arg1)->GetPid();
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 resultobj = SWIG_From_int(static_cast< int >(result));
13634 return resultobj;
13635 fail:
13636 return NULL;
13637 }
13638
13639
13640 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13641 PyObject *resultobj = 0;
13642 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13643 int result;
13644 void *argp1 = 0 ;
13645 int res1 = 0 ;
13646 PyObject *swig_obj[1] ;
13647
13648 if (!args) SWIG_fail;
13649 swig_obj[0] = args;
13650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13651 if (!SWIG_IsOK(res1)) {
13652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13653 }
13654 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13655 {
13656 PyThreadState* __tstate = wxPyBeginAllowThreads();
13657 result = (int)(arg1)->GetExitCode();
13658 wxPyEndAllowThreads(__tstate);
13659 if (PyErr_Occurred()) SWIG_fail;
13660 }
13661 resultobj = SWIG_From_int(static_cast< int >(result));
13662 return resultobj;
13663 fail:
13664 return NULL;
13665 }
13666
13667
13668 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13669 PyObject *resultobj = 0;
13670 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13671 int arg2 ;
13672 void *argp1 = 0 ;
13673 int res1 = 0 ;
13674 int val2 ;
13675 int ecode2 = 0 ;
13676 PyObject *swig_obj[2] ;
13677
13678 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13680 if (!SWIG_IsOK(res1)) {
13681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13682 }
13683 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13684 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13685 if (!SWIG_IsOK(ecode2)) {
13686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13687 }
13688 arg2 = static_cast< int >(val2);
13689 if (arg1) (arg1)->m_pid = arg2;
13690
13691 resultobj = SWIG_Py_Void();
13692 return resultobj;
13693 fail:
13694 return NULL;
13695 }
13696
13697
13698 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13699 PyObject *resultobj = 0;
13700 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13701 int result;
13702 void *argp1 = 0 ;
13703 int res1 = 0 ;
13704 PyObject *swig_obj[1] ;
13705
13706 if (!args) SWIG_fail;
13707 swig_obj[0] = args;
13708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13709 if (!SWIG_IsOK(res1)) {
13710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13711 }
13712 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13713 result = (int) ((arg1)->m_pid);
13714 resultobj = SWIG_From_int(static_cast< int >(result));
13715 return resultobj;
13716 fail:
13717 return NULL;
13718 }
13719
13720
13721 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13722 PyObject *resultobj = 0;
13723 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13724 int arg2 ;
13725 void *argp1 = 0 ;
13726 int res1 = 0 ;
13727 int val2 ;
13728 int ecode2 = 0 ;
13729 PyObject *swig_obj[2] ;
13730
13731 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13733 if (!SWIG_IsOK(res1)) {
13734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13735 }
13736 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13737 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13738 if (!SWIG_IsOK(ecode2)) {
13739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13740 }
13741 arg2 = static_cast< int >(val2);
13742 if (arg1) (arg1)->m_exitcode = arg2;
13743
13744 resultobj = SWIG_Py_Void();
13745 return resultobj;
13746 fail:
13747 return NULL;
13748 }
13749
13750
13751 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13752 PyObject *resultobj = 0;
13753 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13754 int result;
13755 void *argp1 = 0 ;
13756 int res1 = 0 ;
13757 PyObject *swig_obj[1] ;
13758
13759 if (!args) SWIG_fail;
13760 swig_obj[0] = args;
13761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13762 if (!SWIG_IsOK(res1)) {
13763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13764 }
13765 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13766 result = (int) ((arg1)->m_exitcode);
13767 resultobj = SWIG_From_int(static_cast< int >(result));
13768 return resultobj;
13769 fail:
13770 return NULL;
13771 }
13772
13773
13774 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13775 PyObject *obj;
13776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13777 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13778 return SWIG_Py_Void();
13779 }
13780
13781 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13782 return SWIG_Python_InitShadowInstance(args);
13783 }
13784
13785 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13786 PyObject *resultobj = 0;
13787 wxString *arg1 = 0 ;
13788 int arg2 = (int) wxEXEC_ASYNC ;
13789 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13790 long result;
13791 bool temp1 = false ;
13792 int val2 ;
13793 int ecode2 = 0 ;
13794 void *argp3 = 0 ;
13795 int res3 = 0 ;
13796 PyObject * obj0 = 0 ;
13797 PyObject * obj1 = 0 ;
13798 PyObject * obj2 = 0 ;
13799 char * kwnames[] = {
13800 (char *) "command",(char *) "flags",(char *) "process", NULL
13801 };
13802
13803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13804 {
13805 arg1 = wxString_in_helper(obj0);
13806 if (arg1 == NULL) SWIG_fail;
13807 temp1 = true;
13808 }
13809 if (obj1) {
13810 ecode2 = SWIG_AsVal_int(obj1, &val2);
13811 if (!SWIG_IsOK(ecode2)) {
13812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13813 }
13814 arg2 = static_cast< int >(val2);
13815 }
13816 if (obj2) {
13817 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13818 if (!SWIG_IsOK(res3)) {
13819 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13820 }
13821 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13822 }
13823 {
13824 if (!wxPyCheckForApp()) SWIG_fail;
13825 PyThreadState* __tstate = wxPyBeginAllowThreads();
13826 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13827 wxPyEndAllowThreads(__tstate);
13828 if (PyErr_Occurred()) SWIG_fail;
13829 }
13830 resultobj = SWIG_From_long(static_cast< long >(result));
13831 {
13832 if (temp1)
13833 delete arg1;
13834 }
13835 return resultobj;
13836 fail:
13837 {
13838 if (temp1)
13839 delete arg1;
13840 }
13841 return NULL;
13842 }
13843
13844
13845 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13846 PyObject *resultobj = 0;
13847 long arg1 ;
13848 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13849 wxKillError *arg3 = (wxKillError *) 0 ;
13850 int arg4 = (int) wxKILL_NOCHILDREN ;
13851 int result;
13852 long val1 ;
13853 int ecode1 = 0 ;
13854 int val2 ;
13855 int ecode2 = 0 ;
13856 wxKillError temp3 ;
13857 int val4 ;
13858 int ecode4 = 0 ;
13859 PyObject * obj0 = 0 ;
13860 PyObject * obj1 = 0 ;
13861 PyObject * obj2 = 0 ;
13862 char * kwnames[] = {
13863 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13864 };
13865
13866 {
13867 arg3 = &temp3;
13868 }
13869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13870 ecode1 = SWIG_AsVal_long(obj0, &val1);
13871 if (!SWIG_IsOK(ecode1)) {
13872 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13873 }
13874 arg1 = static_cast< long >(val1);
13875 if (obj1) {
13876 ecode2 = SWIG_AsVal_int(obj1, &val2);
13877 if (!SWIG_IsOK(ecode2)) {
13878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13879 }
13880 arg2 = static_cast< wxSignal >(val2);
13881 }
13882 if (obj2) {
13883 ecode4 = SWIG_AsVal_int(obj2, &val4);
13884 if (!SWIG_IsOK(ecode4)) {
13885 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13886 }
13887 arg4 = static_cast< int >(val4);
13888 }
13889 {
13890 PyThreadState* __tstate = wxPyBeginAllowThreads();
13891 result = (int)wxKill(arg1,arg2,arg3,arg4);
13892 wxPyEndAllowThreads(__tstate);
13893 if (PyErr_Occurred()) SWIG_fail;
13894 }
13895 resultobj = SWIG_From_int(static_cast< int >(result));
13896 {
13897 PyObject* o;
13898 o = PyInt_FromLong((long) (*arg3));
13899
13900
13901
13902 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13903
13904 }
13905 return resultobj;
13906 fail:
13907 return NULL;
13908 }
13909
13910
13911 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13912 PyObject *resultobj = 0;
13913 int arg1 = (int) wxJOYSTICK1 ;
13914 wxJoystick *result = 0 ;
13915 int val1 ;
13916 int ecode1 = 0 ;
13917 PyObject * obj0 = 0 ;
13918 char * kwnames[] = {
13919 (char *) "joystick", NULL
13920 };
13921
13922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13923 if (obj0) {
13924 ecode1 = SWIG_AsVal_int(obj0, &val1);
13925 if (!SWIG_IsOK(ecode1)) {
13926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13927 }
13928 arg1 = static_cast< int >(val1);
13929 }
13930 {
13931 if (!wxPyCheckForApp()) SWIG_fail;
13932 PyThreadState* __tstate = wxPyBeginAllowThreads();
13933 result = (wxJoystick *)new wxJoystick(arg1);
13934 wxPyEndAllowThreads(__tstate);
13935 if (PyErr_Occurred()) SWIG_fail;
13936 }
13937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13938 return resultobj;
13939 fail:
13940 return NULL;
13941 }
13942
13943
13944 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13945 PyObject *resultobj = 0;
13946 wxJoystick *arg1 = (wxJoystick *) 0 ;
13947 void *argp1 = 0 ;
13948 int res1 = 0 ;
13949 PyObject *swig_obj[1] ;
13950
13951 if (!args) SWIG_fail;
13952 swig_obj[0] = args;
13953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13954 if (!SWIG_IsOK(res1)) {
13955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13956 }
13957 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13958 {
13959 PyThreadState* __tstate = wxPyBeginAllowThreads();
13960 delete arg1;
13961
13962 wxPyEndAllowThreads(__tstate);
13963 if (PyErr_Occurred()) SWIG_fail;
13964 }
13965 resultobj = SWIG_Py_Void();
13966 return resultobj;
13967 fail:
13968 return NULL;
13969 }
13970
13971
13972 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13973 PyObject *resultobj = 0;
13974 wxJoystick *arg1 = (wxJoystick *) 0 ;
13975 wxPoint result;
13976 void *argp1 = 0 ;
13977 int res1 = 0 ;
13978 PyObject *swig_obj[1] ;
13979
13980 if (!args) SWIG_fail;
13981 swig_obj[0] = args;
13982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13983 if (!SWIG_IsOK(res1)) {
13984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13985 }
13986 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13987 {
13988 PyThreadState* __tstate = wxPyBeginAllowThreads();
13989 result = (arg1)->GetPosition();
13990 wxPyEndAllowThreads(__tstate);
13991 if (PyErr_Occurred()) SWIG_fail;
13992 }
13993 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
13994 return resultobj;
13995 fail:
13996 return NULL;
13997 }
13998
13999
14000 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14001 PyObject *resultobj = 0;
14002 wxJoystick *arg1 = (wxJoystick *) 0 ;
14003 int result;
14004 void *argp1 = 0 ;
14005 int res1 = 0 ;
14006 PyObject *swig_obj[1] ;
14007
14008 if (!args) SWIG_fail;
14009 swig_obj[0] = args;
14010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14011 if (!SWIG_IsOK(res1)) {
14012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14013 }
14014 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 result = (int)(arg1)->GetZPosition();
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 resultobj = SWIG_From_int(static_cast< int >(result));
14022 return resultobj;
14023 fail:
14024 return NULL;
14025 }
14026
14027
14028 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14029 PyObject *resultobj = 0;
14030 wxJoystick *arg1 = (wxJoystick *) 0 ;
14031 int result;
14032 void *argp1 = 0 ;
14033 int res1 = 0 ;
14034 PyObject *swig_obj[1] ;
14035
14036 if (!args) SWIG_fail;
14037 swig_obj[0] = args;
14038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14039 if (!SWIG_IsOK(res1)) {
14040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14041 }
14042 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14043 {
14044 PyThreadState* __tstate = wxPyBeginAllowThreads();
14045 result = (int)(arg1)->GetButtonState();
14046 wxPyEndAllowThreads(__tstate);
14047 if (PyErr_Occurred()) SWIG_fail;
14048 }
14049 resultobj = SWIG_From_int(static_cast< int >(result));
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14057 PyObject *resultobj = 0;
14058 wxJoystick *arg1 = (wxJoystick *) 0 ;
14059 int result;
14060 void *argp1 = 0 ;
14061 int res1 = 0 ;
14062 PyObject *swig_obj[1] ;
14063
14064 if (!args) SWIG_fail;
14065 swig_obj[0] = args;
14066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14067 if (!SWIG_IsOK(res1)) {
14068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14069 }
14070 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14071 {
14072 PyThreadState* __tstate = wxPyBeginAllowThreads();
14073 result = (int)(arg1)->GetPOVPosition();
14074 wxPyEndAllowThreads(__tstate);
14075 if (PyErr_Occurred()) SWIG_fail;
14076 }
14077 resultobj = SWIG_From_int(static_cast< int >(result));
14078 return resultobj;
14079 fail:
14080 return NULL;
14081 }
14082
14083
14084 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14085 PyObject *resultobj = 0;
14086 wxJoystick *arg1 = (wxJoystick *) 0 ;
14087 int result;
14088 void *argp1 = 0 ;
14089 int res1 = 0 ;
14090 PyObject *swig_obj[1] ;
14091
14092 if (!args) SWIG_fail;
14093 swig_obj[0] = args;
14094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14095 if (!SWIG_IsOK(res1)) {
14096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14097 }
14098 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14099 {
14100 PyThreadState* __tstate = wxPyBeginAllowThreads();
14101 result = (int)(arg1)->GetPOVCTSPosition();
14102 wxPyEndAllowThreads(__tstate);
14103 if (PyErr_Occurred()) SWIG_fail;
14104 }
14105 resultobj = SWIG_From_int(static_cast< int >(result));
14106 return resultobj;
14107 fail:
14108 return NULL;
14109 }
14110
14111
14112 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14113 PyObject *resultobj = 0;
14114 wxJoystick *arg1 = (wxJoystick *) 0 ;
14115 int result;
14116 void *argp1 = 0 ;
14117 int res1 = 0 ;
14118 PyObject *swig_obj[1] ;
14119
14120 if (!args) SWIG_fail;
14121 swig_obj[0] = args;
14122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14123 if (!SWIG_IsOK(res1)) {
14124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14125 }
14126 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 result = (int)(arg1)->GetRudderPosition();
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 resultobj = SWIG_From_int(static_cast< int >(result));
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14141 PyObject *resultobj = 0;
14142 wxJoystick *arg1 = (wxJoystick *) 0 ;
14143 int result;
14144 void *argp1 = 0 ;
14145 int res1 = 0 ;
14146 PyObject *swig_obj[1] ;
14147
14148 if (!args) SWIG_fail;
14149 swig_obj[0] = args;
14150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14151 if (!SWIG_IsOK(res1)) {
14152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14153 }
14154 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14155 {
14156 PyThreadState* __tstate = wxPyBeginAllowThreads();
14157 result = (int)(arg1)->GetUPosition();
14158 wxPyEndAllowThreads(__tstate);
14159 if (PyErr_Occurred()) SWIG_fail;
14160 }
14161 resultobj = SWIG_From_int(static_cast< int >(result));
14162 return resultobj;
14163 fail:
14164 return NULL;
14165 }
14166
14167
14168 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14169 PyObject *resultobj = 0;
14170 wxJoystick *arg1 = (wxJoystick *) 0 ;
14171 int result;
14172 void *argp1 = 0 ;
14173 int res1 = 0 ;
14174 PyObject *swig_obj[1] ;
14175
14176 if (!args) SWIG_fail;
14177 swig_obj[0] = args;
14178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14179 if (!SWIG_IsOK(res1)) {
14180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14181 }
14182 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14183 {
14184 PyThreadState* __tstate = wxPyBeginAllowThreads();
14185 result = (int)(arg1)->GetVPosition();
14186 wxPyEndAllowThreads(__tstate);
14187 if (PyErr_Occurred()) SWIG_fail;
14188 }
14189 resultobj = SWIG_From_int(static_cast< int >(result));
14190 return resultobj;
14191 fail:
14192 return NULL;
14193 }
14194
14195
14196 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14197 PyObject *resultobj = 0;
14198 wxJoystick *arg1 = (wxJoystick *) 0 ;
14199 int result;
14200 void *argp1 = 0 ;
14201 int res1 = 0 ;
14202 PyObject *swig_obj[1] ;
14203
14204 if (!args) SWIG_fail;
14205 swig_obj[0] = args;
14206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14207 if (!SWIG_IsOK(res1)) {
14208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14209 }
14210 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14211 {
14212 PyThreadState* __tstate = wxPyBeginAllowThreads();
14213 result = (int)(arg1)->GetMovementThreshold();
14214 wxPyEndAllowThreads(__tstate);
14215 if (PyErr_Occurred()) SWIG_fail;
14216 }
14217 resultobj = SWIG_From_int(static_cast< int >(result));
14218 return resultobj;
14219 fail:
14220 return NULL;
14221 }
14222
14223
14224 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14225 PyObject *resultobj = 0;
14226 wxJoystick *arg1 = (wxJoystick *) 0 ;
14227 int arg2 ;
14228 void *argp1 = 0 ;
14229 int res1 = 0 ;
14230 int val2 ;
14231 int ecode2 = 0 ;
14232 PyObject * obj0 = 0 ;
14233 PyObject * obj1 = 0 ;
14234 char * kwnames[] = {
14235 (char *) "self",(char *) "threshold", NULL
14236 };
14237
14238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14240 if (!SWIG_IsOK(res1)) {
14241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14242 }
14243 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14244 ecode2 = SWIG_AsVal_int(obj1, &val2);
14245 if (!SWIG_IsOK(ecode2)) {
14246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14247 }
14248 arg2 = static_cast< int >(val2);
14249 {
14250 PyThreadState* __tstate = wxPyBeginAllowThreads();
14251 (arg1)->SetMovementThreshold(arg2);
14252 wxPyEndAllowThreads(__tstate);
14253 if (PyErr_Occurred()) SWIG_fail;
14254 }
14255 resultobj = SWIG_Py_Void();
14256 return resultobj;
14257 fail:
14258 return NULL;
14259 }
14260
14261
14262 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14263 PyObject *resultobj = 0;
14264 wxJoystick *arg1 = (wxJoystick *) 0 ;
14265 bool result;
14266 void *argp1 = 0 ;
14267 int res1 = 0 ;
14268 PyObject *swig_obj[1] ;
14269
14270 if (!args) SWIG_fail;
14271 swig_obj[0] = args;
14272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14273 if (!SWIG_IsOK(res1)) {
14274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14275 }
14276 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14277 {
14278 PyThreadState* __tstate = wxPyBeginAllowThreads();
14279 result = (bool)(arg1)->IsOk();
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 {
14284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14285 }
14286 return resultobj;
14287 fail:
14288 return NULL;
14289 }
14290
14291
14292 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14293 PyObject *resultobj = 0;
14294 wxJoystick *arg1 = (wxJoystick *) 0 ;
14295 int result;
14296 void *argp1 = 0 ;
14297 int res1 = 0 ;
14298 PyObject *swig_obj[1] ;
14299
14300 if (!args) SWIG_fail;
14301 swig_obj[0] = args;
14302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14303 if (!SWIG_IsOK(res1)) {
14304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14305 }
14306 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (int)(arg1)->GetNumberJoysticks();
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 resultobj = SWIG_From_int(static_cast< int >(result));
14314 return resultobj;
14315 fail:
14316 return NULL;
14317 }
14318
14319
14320 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14321 PyObject *resultobj = 0;
14322 wxJoystick *arg1 = (wxJoystick *) 0 ;
14323 int result;
14324 void *argp1 = 0 ;
14325 int res1 = 0 ;
14326 PyObject *swig_obj[1] ;
14327
14328 if (!args) SWIG_fail;
14329 swig_obj[0] = args;
14330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14331 if (!SWIG_IsOK(res1)) {
14332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14333 }
14334 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14335 {
14336 PyThreadState* __tstate = wxPyBeginAllowThreads();
14337 result = (int)(arg1)->GetManufacturerId();
14338 wxPyEndAllowThreads(__tstate);
14339 if (PyErr_Occurred()) SWIG_fail;
14340 }
14341 resultobj = SWIG_From_int(static_cast< int >(result));
14342 return resultobj;
14343 fail:
14344 return NULL;
14345 }
14346
14347
14348 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14349 PyObject *resultobj = 0;
14350 wxJoystick *arg1 = (wxJoystick *) 0 ;
14351 int result;
14352 void *argp1 = 0 ;
14353 int res1 = 0 ;
14354 PyObject *swig_obj[1] ;
14355
14356 if (!args) SWIG_fail;
14357 swig_obj[0] = args;
14358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14359 if (!SWIG_IsOK(res1)) {
14360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14361 }
14362 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14363 {
14364 PyThreadState* __tstate = wxPyBeginAllowThreads();
14365 result = (int)(arg1)->GetProductId();
14366 wxPyEndAllowThreads(__tstate);
14367 if (PyErr_Occurred()) SWIG_fail;
14368 }
14369 resultobj = SWIG_From_int(static_cast< int >(result));
14370 return resultobj;
14371 fail:
14372 return NULL;
14373 }
14374
14375
14376 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14377 PyObject *resultobj = 0;
14378 wxJoystick *arg1 = (wxJoystick *) 0 ;
14379 wxString result;
14380 void *argp1 = 0 ;
14381 int res1 = 0 ;
14382 PyObject *swig_obj[1] ;
14383
14384 if (!args) SWIG_fail;
14385 swig_obj[0] = args;
14386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14387 if (!SWIG_IsOK(res1)) {
14388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14389 }
14390 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14391 {
14392 PyThreadState* __tstate = wxPyBeginAllowThreads();
14393 result = (arg1)->GetProductName();
14394 wxPyEndAllowThreads(__tstate);
14395 if (PyErr_Occurred()) SWIG_fail;
14396 }
14397 {
14398 #if wxUSE_UNICODE
14399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14400 #else
14401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14402 #endif
14403 }
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14411 PyObject *resultobj = 0;
14412 wxJoystick *arg1 = (wxJoystick *) 0 ;
14413 int result;
14414 void *argp1 = 0 ;
14415 int res1 = 0 ;
14416 PyObject *swig_obj[1] ;
14417
14418 if (!args) SWIG_fail;
14419 swig_obj[0] = args;
14420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14421 if (!SWIG_IsOK(res1)) {
14422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14423 }
14424 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14425 {
14426 PyThreadState* __tstate = wxPyBeginAllowThreads();
14427 result = (int)(arg1)->GetXMin();
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 resultobj = SWIG_From_int(static_cast< int >(result));
14432 return resultobj;
14433 fail:
14434 return NULL;
14435 }
14436
14437
14438 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14439 PyObject *resultobj = 0;
14440 wxJoystick *arg1 = (wxJoystick *) 0 ;
14441 int result;
14442 void *argp1 = 0 ;
14443 int res1 = 0 ;
14444 PyObject *swig_obj[1] ;
14445
14446 if (!args) SWIG_fail;
14447 swig_obj[0] = args;
14448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14449 if (!SWIG_IsOK(res1)) {
14450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14451 }
14452 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14453 {
14454 PyThreadState* __tstate = wxPyBeginAllowThreads();
14455 result = (int)(arg1)->GetYMin();
14456 wxPyEndAllowThreads(__tstate);
14457 if (PyErr_Occurred()) SWIG_fail;
14458 }
14459 resultobj = SWIG_From_int(static_cast< int >(result));
14460 return resultobj;
14461 fail:
14462 return NULL;
14463 }
14464
14465
14466 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14467 PyObject *resultobj = 0;
14468 wxJoystick *arg1 = (wxJoystick *) 0 ;
14469 int result;
14470 void *argp1 = 0 ;
14471 int res1 = 0 ;
14472 PyObject *swig_obj[1] ;
14473
14474 if (!args) SWIG_fail;
14475 swig_obj[0] = args;
14476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14477 if (!SWIG_IsOK(res1)) {
14478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14479 }
14480 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14481 {
14482 PyThreadState* __tstate = wxPyBeginAllowThreads();
14483 result = (int)(arg1)->GetZMin();
14484 wxPyEndAllowThreads(__tstate);
14485 if (PyErr_Occurred()) SWIG_fail;
14486 }
14487 resultobj = SWIG_From_int(static_cast< int >(result));
14488 return resultobj;
14489 fail:
14490 return NULL;
14491 }
14492
14493
14494 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14495 PyObject *resultobj = 0;
14496 wxJoystick *arg1 = (wxJoystick *) 0 ;
14497 int result;
14498 void *argp1 = 0 ;
14499 int res1 = 0 ;
14500 PyObject *swig_obj[1] ;
14501
14502 if (!args) SWIG_fail;
14503 swig_obj[0] = args;
14504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14505 if (!SWIG_IsOK(res1)) {
14506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14507 }
14508 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14509 {
14510 PyThreadState* __tstate = wxPyBeginAllowThreads();
14511 result = (int)(arg1)->GetXMax();
14512 wxPyEndAllowThreads(__tstate);
14513 if (PyErr_Occurred()) SWIG_fail;
14514 }
14515 resultobj = SWIG_From_int(static_cast< int >(result));
14516 return resultobj;
14517 fail:
14518 return NULL;
14519 }
14520
14521
14522 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14523 PyObject *resultobj = 0;
14524 wxJoystick *arg1 = (wxJoystick *) 0 ;
14525 int result;
14526 void *argp1 = 0 ;
14527 int res1 = 0 ;
14528 PyObject *swig_obj[1] ;
14529
14530 if (!args) SWIG_fail;
14531 swig_obj[0] = args;
14532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14533 if (!SWIG_IsOK(res1)) {
14534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14535 }
14536 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14537 {
14538 PyThreadState* __tstate = wxPyBeginAllowThreads();
14539 result = (int)(arg1)->GetYMax();
14540 wxPyEndAllowThreads(__tstate);
14541 if (PyErr_Occurred()) SWIG_fail;
14542 }
14543 resultobj = SWIG_From_int(static_cast< int >(result));
14544 return resultobj;
14545 fail:
14546 return NULL;
14547 }
14548
14549
14550 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14551 PyObject *resultobj = 0;
14552 wxJoystick *arg1 = (wxJoystick *) 0 ;
14553 int result;
14554 void *argp1 = 0 ;
14555 int res1 = 0 ;
14556 PyObject *swig_obj[1] ;
14557
14558 if (!args) SWIG_fail;
14559 swig_obj[0] = args;
14560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14561 if (!SWIG_IsOK(res1)) {
14562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14563 }
14564 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14565 {
14566 PyThreadState* __tstate = wxPyBeginAllowThreads();
14567 result = (int)(arg1)->GetZMax();
14568 wxPyEndAllowThreads(__tstate);
14569 if (PyErr_Occurred()) SWIG_fail;
14570 }
14571 resultobj = SWIG_From_int(static_cast< int >(result));
14572 return resultobj;
14573 fail:
14574 return NULL;
14575 }
14576
14577
14578 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14579 PyObject *resultobj = 0;
14580 wxJoystick *arg1 = (wxJoystick *) 0 ;
14581 int result;
14582 void *argp1 = 0 ;
14583 int res1 = 0 ;
14584 PyObject *swig_obj[1] ;
14585
14586 if (!args) SWIG_fail;
14587 swig_obj[0] = args;
14588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14589 if (!SWIG_IsOK(res1)) {
14590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14591 }
14592 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14593 {
14594 PyThreadState* __tstate = wxPyBeginAllowThreads();
14595 result = (int)(arg1)->GetNumberButtons();
14596 wxPyEndAllowThreads(__tstate);
14597 if (PyErr_Occurred()) SWIG_fail;
14598 }
14599 resultobj = SWIG_From_int(static_cast< int >(result));
14600 return resultobj;
14601 fail:
14602 return NULL;
14603 }
14604
14605
14606 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14607 PyObject *resultobj = 0;
14608 wxJoystick *arg1 = (wxJoystick *) 0 ;
14609 int result;
14610 void *argp1 = 0 ;
14611 int res1 = 0 ;
14612 PyObject *swig_obj[1] ;
14613
14614 if (!args) SWIG_fail;
14615 swig_obj[0] = args;
14616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14617 if (!SWIG_IsOK(res1)) {
14618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14619 }
14620 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14621 {
14622 PyThreadState* __tstate = wxPyBeginAllowThreads();
14623 result = (int)(arg1)->GetNumberAxes();
14624 wxPyEndAllowThreads(__tstate);
14625 if (PyErr_Occurred()) SWIG_fail;
14626 }
14627 resultobj = SWIG_From_int(static_cast< int >(result));
14628 return resultobj;
14629 fail:
14630 return NULL;
14631 }
14632
14633
14634 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14635 PyObject *resultobj = 0;
14636 wxJoystick *arg1 = (wxJoystick *) 0 ;
14637 int result;
14638 void *argp1 = 0 ;
14639 int res1 = 0 ;
14640 PyObject *swig_obj[1] ;
14641
14642 if (!args) SWIG_fail;
14643 swig_obj[0] = args;
14644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14645 if (!SWIG_IsOK(res1)) {
14646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14647 }
14648 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14649 {
14650 PyThreadState* __tstate = wxPyBeginAllowThreads();
14651 result = (int)(arg1)->GetMaxButtons();
14652 wxPyEndAllowThreads(__tstate);
14653 if (PyErr_Occurred()) SWIG_fail;
14654 }
14655 resultobj = SWIG_From_int(static_cast< int >(result));
14656 return resultobj;
14657 fail:
14658 return NULL;
14659 }
14660
14661
14662 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14663 PyObject *resultobj = 0;
14664 wxJoystick *arg1 = (wxJoystick *) 0 ;
14665 int result;
14666 void *argp1 = 0 ;
14667 int res1 = 0 ;
14668 PyObject *swig_obj[1] ;
14669
14670 if (!args) SWIG_fail;
14671 swig_obj[0] = args;
14672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14673 if (!SWIG_IsOK(res1)) {
14674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14675 }
14676 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 result = (int)(arg1)->GetMaxAxes();
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 resultobj = SWIG_From_int(static_cast< int >(result));
14684 return resultobj;
14685 fail:
14686 return NULL;
14687 }
14688
14689
14690 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14691 PyObject *resultobj = 0;
14692 wxJoystick *arg1 = (wxJoystick *) 0 ;
14693 int result;
14694 void *argp1 = 0 ;
14695 int res1 = 0 ;
14696 PyObject *swig_obj[1] ;
14697
14698 if (!args) SWIG_fail;
14699 swig_obj[0] = args;
14700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14701 if (!SWIG_IsOK(res1)) {
14702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14703 }
14704 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14705 {
14706 PyThreadState* __tstate = wxPyBeginAllowThreads();
14707 result = (int)(arg1)->GetPollingMin();
14708 wxPyEndAllowThreads(__tstate);
14709 if (PyErr_Occurred()) SWIG_fail;
14710 }
14711 resultobj = SWIG_From_int(static_cast< int >(result));
14712 return resultobj;
14713 fail:
14714 return NULL;
14715 }
14716
14717
14718 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14719 PyObject *resultobj = 0;
14720 wxJoystick *arg1 = (wxJoystick *) 0 ;
14721 int result;
14722 void *argp1 = 0 ;
14723 int res1 = 0 ;
14724 PyObject *swig_obj[1] ;
14725
14726 if (!args) SWIG_fail;
14727 swig_obj[0] = args;
14728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14729 if (!SWIG_IsOK(res1)) {
14730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14731 }
14732 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14733 {
14734 PyThreadState* __tstate = wxPyBeginAllowThreads();
14735 result = (int)(arg1)->GetPollingMax();
14736 wxPyEndAllowThreads(__tstate);
14737 if (PyErr_Occurred()) SWIG_fail;
14738 }
14739 resultobj = SWIG_From_int(static_cast< int >(result));
14740 return resultobj;
14741 fail:
14742 return NULL;
14743 }
14744
14745
14746 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14747 PyObject *resultobj = 0;
14748 wxJoystick *arg1 = (wxJoystick *) 0 ;
14749 int result;
14750 void *argp1 = 0 ;
14751 int res1 = 0 ;
14752 PyObject *swig_obj[1] ;
14753
14754 if (!args) SWIG_fail;
14755 swig_obj[0] = args;
14756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14757 if (!SWIG_IsOK(res1)) {
14758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14759 }
14760 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14761 {
14762 PyThreadState* __tstate = wxPyBeginAllowThreads();
14763 result = (int)(arg1)->GetRudderMin();
14764 wxPyEndAllowThreads(__tstate);
14765 if (PyErr_Occurred()) SWIG_fail;
14766 }
14767 resultobj = SWIG_From_int(static_cast< int >(result));
14768 return resultobj;
14769 fail:
14770 return NULL;
14771 }
14772
14773
14774 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14775 PyObject *resultobj = 0;
14776 wxJoystick *arg1 = (wxJoystick *) 0 ;
14777 int result;
14778 void *argp1 = 0 ;
14779 int res1 = 0 ;
14780 PyObject *swig_obj[1] ;
14781
14782 if (!args) SWIG_fail;
14783 swig_obj[0] = args;
14784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14785 if (!SWIG_IsOK(res1)) {
14786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14787 }
14788 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 result = (int)(arg1)->GetRudderMax();
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 resultobj = SWIG_From_int(static_cast< int >(result));
14796 return resultobj;
14797 fail:
14798 return NULL;
14799 }
14800
14801
14802 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14803 PyObject *resultobj = 0;
14804 wxJoystick *arg1 = (wxJoystick *) 0 ;
14805 int result;
14806 void *argp1 = 0 ;
14807 int res1 = 0 ;
14808 PyObject *swig_obj[1] ;
14809
14810 if (!args) SWIG_fail;
14811 swig_obj[0] = args;
14812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14813 if (!SWIG_IsOK(res1)) {
14814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14815 }
14816 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14817 {
14818 PyThreadState* __tstate = wxPyBeginAllowThreads();
14819 result = (int)(arg1)->GetUMin();
14820 wxPyEndAllowThreads(__tstate);
14821 if (PyErr_Occurred()) SWIG_fail;
14822 }
14823 resultobj = SWIG_From_int(static_cast< int >(result));
14824 return resultobj;
14825 fail:
14826 return NULL;
14827 }
14828
14829
14830 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14831 PyObject *resultobj = 0;
14832 wxJoystick *arg1 = (wxJoystick *) 0 ;
14833 int result;
14834 void *argp1 = 0 ;
14835 int res1 = 0 ;
14836 PyObject *swig_obj[1] ;
14837
14838 if (!args) SWIG_fail;
14839 swig_obj[0] = args;
14840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14841 if (!SWIG_IsOK(res1)) {
14842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14843 }
14844 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14845 {
14846 PyThreadState* __tstate = wxPyBeginAllowThreads();
14847 result = (int)(arg1)->GetUMax();
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 resultobj = SWIG_From_int(static_cast< int >(result));
14852 return resultobj;
14853 fail:
14854 return NULL;
14855 }
14856
14857
14858 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14859 PyObject *resultobj = 0;
14860 wxJoystick *arg1 = (wxJoystick *) 0 ;
14861 int result;
14862 void *argp1 = 0 ;
14863 int res1 = 0 ;
14864 PyObject *swig_obj[1] ;
14865
14866 if (!args) SWIG_fail;
14867 swig_obj[0] = args;
14868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14869 if (!SWIG_IsOK(res1)) {
14870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14871 }
14872 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14873 {
14874 PyThreadState* __tstate = wxPyBeginAllowThreads();
14875 result = (int)(arg1)->GetVMin();
14876 wxPyEndAllowThreads(__tstate);
14877 if (PyErr_Occurred()) SWIG_fail;
14878 }
14879 resultobj = SWIG_From_int(static_cast< int >(result));
14880 return resultobj;
14881 fail:
14882 return NULL;
14883 }
14884
14885
14886 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14887 PyObject *resultobj = 0;
14888 wxJoystick *arg1 = (wxJoystick *) 0 ;
14889 int result;
14890 void *argp1 = 0 ;
14891 int res1 = 0 ;
14892 PyObject *swig_obj[1] ;
14893
14894 if (!args) SWIG_fail;
14895 swig_obj[0] = args;
14896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14897 if (!SWIG_IsOK(res1)) {
14898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14899 }
14900 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14901 {
14902 PyThreadState* __tstate = wxPyBeginAllowThreads();
14903 result = (int)(arg1)->GetVMax();
14904 wxPyEndAllowThreads(__tstate);
14905 if (PyErr_Occurred()) SWIG_fail;
14906 }
14907 resultobj = SWIG_From_int(static_cast< int >(result));
14908 return resultobj;
14909 fail:
14910 return NULL;
14911 }
14912
14913
14914 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14915 PyObject *resultobj = 0;
14916 wxJoystick *arg1 = (wxJoystick *) 0 ;
14917 bool result;
14918 void *argp1 = 0 ;
14919 int res1 = 0 ;
14920 PyObject *swig_obj[1] ;
14921
14922 if (!args) SWIG_fail;
14923 swig_obj[0] = args;
14924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14925 if (!SWIG_IsOK(res1)) {
14926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14927 }
14928 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14929 {
14930 PyThreadState* __tstate = wxPyBeginAllowThreads();
14931 result = (bool)(arg1)->HasRudder();
14932 wxPyEndAllowThreads(__tstate);
14933 if (PyErr_Occurred()) SWIG_fail;
14934 }
14935 {
14936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14937 }
14938 return resultobj;
14939 fail:
14940 return NULL;
14941 }
14942
14943
14944 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14945 PyObject *resultobj = 0;
14946 wxJoystick *arg1 = (wxJoystick *) 0 ;
14947 bool result;
14948 void *argp1 = 0 ;
14949 int res1 = 0 ;
14950 PyObject *swig_obj[1] ;
14951
14952 if (!args) SWIG_fail;
14953 swig_obj[0] = args;
14954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14955 if (!SWIG_IsOK(res1)) {
14956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14957 }
14958 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14959 {
14960 PyThreadState* __tstate = wxPyBeginAllowThreads();
14961 result = (bool)(arg1)->HasZ();
14962 wxPyEndAllowThreads(__tstate);
14963 if (PyErr_Occurred()) SWIG_fail;
14964 }
14965 {
14966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14967 }
14968 return resultobj;
14969 fail:
14970 return NULL;
14971 }
14972
14973
14974 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14975 PyObject *resultobj = 0;
14976 wxJoystick *arg1 = (wxJoystick *) 0 ;
14977 bool result;
14978 void *argp1 = 0 ;
14979 int res1 = 0 ;
14980 PyObject *swig_obj[1] ;
14981
14982 if (!args) SWIG_fail;
14983 swig_obj[0] = args;
14984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14985 if (!SWIG_IsOK(res1)) {
14986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14987 }
14988 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 result = (bool)(arg1)->HasU();
14992 wxPyEndAllowThreads(__tstate);
14993 if (PyErr_Occurred()) SWIG_fail;
14994 }
14995 {
14996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14997 }
14998 return resultobj;
14999 fail:
15000 return NULL;
15001 }
15002
15003
15004 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15005 PyObject *resultobj = 0;
15006 wxJoystick *arg1 = (wxJoystick *) 0 ;
15007 bool result;
15008 void *argp1 = 0 ;
15009 int res1 = 0 ;
15010 PyObject *swig_obj[1] ;
15011
15012 if (!args) SWIG_fail;
15013 swig_obj[0] = args;
15014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15015 if (!SWIG_IsOK(res1)) {
15016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15017 }
15018 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15019 {
15020 PyThreadState* __tstate = wxPyBeginAllowThreads();
15021 result = (bool)(arg1)->HasV();
15022 wxPyEndAllowThreads(__tstate);
15023 if (PyErr_Occurred()) SWIG_fail;
15024 }
15025 {
15026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15027 }
15028 return resultobj;
15029 fail:
15030 return NULL;
15031 }
15032
15033
15034 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15035 PyObject *resultobj = 0;
15036 wxJoystick *arg1 = (wxJoystick *) 0 ;
15037 bool result;
15038 void *argp1 = 0 ;
15039 int res1 = 0 ;
15040 PyObject *swig_obj[1] ;
15041
15042 if (!args) SWIG_fail;
15043 swig_obj[0] = args;
15044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15045 if (!SWIG_IsOK(res1)) {
15046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15047 }
15048 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15049 {
15050 PyThreadState* __tstate = wxPyBeginAllowThreads();
15051 result = (bool)(arg1)->HasPOV();
15052 wxPyEndAllowThreads(__tstate);
15053 if (PyErr_Occurred()) SWIG_fail;
15054 }
15055 {
15056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15057 }
15058 return resultobj;
15059 fail:
15060 return NULL;
15061 }
15062
15063
15064 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15065 PyObject *resultobj = 0;
15066 wxJoystick *arg1 = (wxJoystick *) 0 ;
15067 bool result;
15068 void *argp1 = 0 ;
15069 int res1 = 0 ;
15070 PyObject *swig_obj[1] ;
15071
15072 if (!args) SWIG_fail;
15073 swig_obj[0] = args;
15074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15075 if (!SWIG_IsOK(res1)) {
15076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15077 }
15078 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15079 {
15080 PyThreadState* __tstate = wxPyBeginAllowThreads();
15081 result = (bool)(arg1)->HasPOV4Dir();
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 {
15086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15087 }
15088 return resultobj;
15089 fail:
15090 return NULL;
15091 }
15092
15093
15094 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15095 PyObject *resultobj = 0;
15096 wxJoystick *arg1 = (wxJoystick *) 0 ;
15097 bool result;
15098 void *argp1 = 0 ;
15099 int res1 = 0 ;
15100 PyObject *swig_obj[1] ;
15101
15102 if (!args) SWIG_fail;
15103 swig_obj[0] = args;
15104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15105 if (!SWIG_IsOK(res1)) {
15106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15107 }
15108 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15109 {
15110 PyThreadState* __tstate = wxPyBeginAllowThreads();
15111 result = (bool)(arg1)->HasPOVCTS();
15112 wxPyEndAllowThreads(__tstate);
15113 if (PyErr_Occurred()) SWIG_fail;
15114 }
15115 {
15116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15117 }
15118 return resultobj;
15119 fail:
15120 return NULL;
15121 }
15122
15123
15124 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15125 PyObject *resultobj = 0;
15126 wxJoystick *arg1 = (wxJoystick *) 0 ;
15127 wxWindow *arg2 = (wxWindow *) 0 ;
15128 int arg3 = (int) 0 ;
15129 bool result;
15130 void *argp1 = 0 ;
15131 int res1 = 0 ;
15132 void *argp2 = 0 ;
15133 int res2 = 0 ;
15134 int val3 ;
15135 int ecode3 = 0 ;
15136 PyObject * obj0 = 0 ;
15137 PyObject * obj1 = 0 ;
15138 PyObject * obj2 = 0 ;
15139 char * kwnames[] = {
15140 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15141 };
15142
15143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15145 if (!SWIG_IsOK(res1)) {
15146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15147 }
15148 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15150 if (!SWIG_IsOK(res2)) {
15151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15152 }
15153 arg2 = reinterpret_cast< wxWindow * >(argp2);
15154 if (obj2) {
15155 ecode3 = SWIG_AsVal_int(obj2, &val3);
15156 if (!SWIG_IsOK(ecode3)) {
15157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15158 }
15159 arg3 = static_cast< int >(val3);
15160 }
15161 {
15162 PyThreadState* __tstate = wxPyBeginAllowThreads();
15163 result = (bool)(arg1)->SetCapture(arg2,arg3);
15164 wxPyEndAllowThreads(__tstate);
15165 if (PyErr_Occurred()) SWIG_fail;
15166 }
15167 {
15168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15169 }
15170 return resultobj;
15171 fail:
15172 return NULL;
15173 }
15174
15175
15176 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15177 PyObject *resultobj = 0;
15178 wxJoystick *arg1 = (wxJoystick *) 0 ;
15179 bool result;
15180 void *argp1 = 0 ;
15181 int res1 = 0 ;
15182 PyObject *swig_obj[1] ;
15183
15184 if (!args) SWIG_fail;
15185 swig_obj[0] = args;
15186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15187 if (!SWIG_IsOK(res1)) {
15188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15189 }
15190 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15191 {
15192 PyThreadState* __tstate = wxPyBeginAllowThreads();
15193 result = (bool)(arg1)->ReleaseCapture();
15194 wxPyEndAllowThreads(__tstate);
15195 if (PyErr_Occurred()) SWIG_fail;
15196 }
15197 {
15198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15199 }
15200 return resultobj;
15201 fail:
15202 return NULL;
15203 }
15204
15205
15206 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15207 PyObject *obj;
15208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15209 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15210 return SWIG_Py_Void();
15211 }
15212
15213 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15214 return SWIG_Python_InitShadowInstance(args);
15215 }
15216
15217 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15218 PyObject *resultobj = 0;
15219 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15220 int arg2 = (int) 0 ;
15221 int arg3 = (int) wxJOYSTICK1 ;
15222 int arg4 = (int) 0 ;
15223 wxJoystickEvent *result = 0 ;
15224 int val1 ;
15225 int ecode1 = 0 ;
15226 int val2 ;
15227 int ecode2 = 0 ;
15228 int val3 ;
15229 int ecode3 = 0 ;
15230 int val4 ;
15231 int ecode4 = 0 ;
15232 PyObject * obj0 = 0 ;
15233 PyObject * obj1 = 0 ;
15234 PyObject * obj2 = 0 ;
15235 PyObject * obj3 = 0 ;
15236 char * kwnames[] = {
15237 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15238 };
15239
15240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15241 if (obj0) {
15242 ecode1 = SWIG_AsVal_int(obj0, &val1);
15243 if (!SWIG_IsOK(ecode1)) {
15244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15245 }
15246 arg1 = static_cast< wxEventType >(val1);
15247 }
15248 if (obj1) {
15249 ecode2 = SWIG_AsVal_int(obj1, &val2);
15250 if (!SWIG_IsOK(ecode2)) {
15251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15252 }
15253 arg2 = static_cast< int >(val2);
15254 }
15255 if (obj2) {
15256 ecode3 = SWIG_AsVal_int(obj2, &val3);
15257 if (!SWIG_IsOK(ecode3)) {
15258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15259 }
15260 arg3 = static_cast< int >(val3);
15261 }
15262 if (obj3) {
15263 ecode4 = SWIG_AsVal_int(obj3, &val4);
15264 if (!SWIG_IsOK(ecode4)) {
15265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15266 }
15267 arg4 = static_cast< int >(val4);
15268 }
15269 {
15270 PyThreadState* __tstate = wxPyBeginAllowThreads();
15271 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15272 wxPyEndAllowThreads(__tstate);
15273 if (PyErr_Occurred()) SWIG_fail;
15274 }
15275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15276 return resultobj;
15277 fail:
15278 return NULL;
15279 }
15280
15281
15282 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15283 PyObject *resultobj = 0;
15284 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15285 wxPoint result;
15286 void *argp1 = 0 ;
15287 int res1 = 0 ;
15288 PyObject *swig_obj[1] ;
15289
15290 if (!args) SWIG_fail;
15291 swig_obj[0] = args;
15292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15293 if (!SWIG_IsOK(res1)) {
15294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15295 }
15296 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15297 {
15298 PyThreadState* __tstate = wxPyBeginAllowThreads();
15299 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15300 wxPyEndAllowThreads(__tstate);
15301 if (PyErr_Occurred()) SWIG_fail;
15302 }
15303 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15304 return resultobj;
15305 fail:
15306 return NULL;
15307 }
15308
15309
15310 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15311 PyObject *resultobj = 0;
15312 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15313 int 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_wxJoystickEvent, 0 | 0 );
15321 if (!SWIG_IsOK(res1)) {
15322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15323 }
15324 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15325 {
15326 PyThreadState* __tstate = wxPyBeginAllowThreads();
15327 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15328 wxPyEndAllowThreads(__tstate);
15329 if (PyErr_Occurred()) SWIG_fail;
15330 }
15331 resultobj = SWIG_From_int(static_cast< int >(result));
15332 return resultobj;
15333 fail:
15334 return NULL;
15335 }
15336
15337
15338 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15339 PyObject *resultobj = 0;
15340 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15341 int result;
15342 void *argp1 = 0 ;
15343 int res1 = 0 ;
15344 PyObject *swig_obj[1] ;
15345
15346 if (!args) SWIG_fail;
15347 swig_obj[0] = args;
15348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15349 if (!SWIG_IsOK(res1)) {
15350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15351 }
15352 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15353 {
15354 PyThreadState* __tstate = wxPyBeginAllowThreads();
15355 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15356 wxPyEndAllowThreads(__tstate);
15357 if (PyErr_Occurred()) SWIG_fail;
15358 }
15359 resultobj = SWIG_From_int(static_cast< int >(result));
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15367 PyObject *resultobj = 0;
15368 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15369 int result;
15370 void *argp1 = 0 ;
15371 int res1 = 0 ;
15372 PyObject *swig_obj[1] ;
15373
15374 if (!args) SWIG_fail;
15375 swig_obj[0] = args;
15376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15377 if (!SWIG_IsOK(res1)) {
15378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15379 }
15380 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15381 {
15382 PyThreadState* __tstate = wxPyBeginAllowThreads();
15383 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 resultobj = SWIG_From_int(static_cast< int >(result));
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15395 PyObject *resultobj = 0;
15396 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15397 int result;
15398 void *argp1 = 0 ;
15399 int res1 = 0 ;
15400 PyObject *swig_obj[1] ;
15401
15402 if (!args) SWIG_fail;
15403 swig_obj[0] = args;
15404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15405 if (!SWIG_IsOK(res1)) {
15406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15407 }
15408 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15409 {
15410 PyThreadState* __tstate = wxPyBeginAllowThreads();
15411 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15412 wxPyEndAllowThreads(__tstate);
15413 if (PyErr_Occurred()) SWIG_fail;
15414 }
15415 resultobj = SWIG_From_int(static_cast< int >(result));
15416 return resultobj;
15417 fail:
15418 return NULL;
15419 }
15420
15421
15422 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15423 PyObject *resultobj = 0;
15424 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15425 int arg2 ;
15426 void *argp1 = 0 ;
15427 int res1 = 0 ;
15428 int val2 ;
15429 int ecode2 = 0 ;
15430 PyObject * obj0 = 0 ;
15431 PyObject * obj1 = 0 ;
15432 char * kwnames[] = {
15433 (char *) "self",(char *) "stick", NULL
15434 };
15435
15436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15438 if (!SWIG_IsOK(res1)) {
15439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15440 }
15441 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15442 ecode2 = SWIG_AsVal_int(obj1, &val2);
15443 if (!SWIG_IsOK(ecode2)) {
15444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15445 }
15446 arg2 = static_cast< int >(val2);
15447 {
15448 PyThreadState* __tstate = wxPyBeginAllowThreads();
15449 (arg1)->SetJoystick(arg2);
15450 wxPyEndAllowThreads(__tstate);
15451 if (PyErr_Occurred()) SWIG_fail;
15452 }
15453 resultobj = SWIG_Py_Void();
15454 return resultobj;
15455 fail:
15456 return NULL;
15457 }
15458
15459
15460 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15461 PyObject *resultobj = 0;
15462 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15463 int arg2 ;
15464 void *argp1 = 0 ;
15465 int res1 = 0 ;
15466 int val2 ;
15467 int ecode2 = 0 ;
15468 PyObject * obj0 = 0 ;
15469 PyObject * obj1 = 0 ;
15470 char * kwnames[] = {
15471 (char *) "self",(char *) "state", NULL
15472 };
15473
15474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15476 if (!SWIG_IsOK(res1)) {
15477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15478 }
15479 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15480 ecode2 = SWIG_AsVal_int(obj1, &val2);
15481 if (!SWIG_IsOK(ecode2)) {
15482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15483 }
15484 arg2 = static_cast< int >(val2);
15485 {
15486 PyThreadState* __tstate = wxPyBeginAllowThreads();
15487 (arg1)->SetButtonState(arg2);
15488 wxPyEndAllowThreads(__tstate);
15489 if (PyErr_Occurred()) SWIG_fail;
15490 }
15491 resultobj = SWIG_Py_Void();
15492 return resultobj;
15493 fail:
15494 return NULL;
15495 }
15496
15497
15498 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15499 PyObject *resultobj = 0;
15500 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15501 int arg2 ;
15502 void *argp1 = 0 ;
15503 int res1 = 0 ;
15504 int val2 ;
15505 int ecode2 = 0 ;
15506 PyObject * obj0 = 0 ;
15507 PyObject * obj1 = 0 ;
15508 char * kwnames[] = {
15509 (char *) "self",(char *) "change", NULL
15510 };
15511
15512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15514 if (!SWIG_IsOK(res1)) {
15515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15516 }
15517 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15518 ecode2 = SWIG_AsVal_int(obj1, &val2);
15519 if (!SWIG_IsOK(ecode2)) {
15520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15521 }
15522 arg2 = static_cast< int >(val2);
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 (arg1)->SetButtonChange(arg2);
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 resultobj = SWIG_Py_Void();
15530 return resultobj;
15531 fail:
15532 return NULL;
15533 }
15534
15535
15536 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15537 PyObject *resultobj = 0;
15538 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15539 wxPoint *arg2 = 0 ;
15540 void *argp1 = 0 ;
15541 int res1 = 0 ;
15542 wxPoint temp2 ;
15543 PyObject * obj0 = 0 ;
15544 PyObject * obj1 = 0 ;
15545 char * kwnames[] = {
15546 (char *) "self",(char *) "pos", NULL
15547 };
15548
15549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15551 if (!SWIG_IsOK(res1)) {
15552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15553 }
15554 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15555 {
15556 arg2 = &temp2;
15557 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15558 }
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 (arg1)->SetPosition((wxPoint const &)*arg2);
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 resultobj = SWIG_Py_Void();
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15573 PyObject *resultobj = 0;
15574 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15575 int arg2 ;
15576 void *argp1 = 0 ;
15577 int res1 = 0 ;
15578 int val2 ;
15579 int ecode2 = 0 ;
15580 PyObject * obj0 = 0 ;
15581 PyObject * obj1 = 0 ;
15582 char * kwnames[] = {
15583 (char *) "self",(char *) "zPos", NULL
15584 };
15585
15586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15588 if (!SWIG_IsOK(res1)) {
15589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15590 }
15591 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15592 ecode2 = SWIG_AsVal_int(obj1, &val2);
15593 if (!SWIG_IsOK(ecode2)) {
15594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15595 }
15596 arg2 = static_cast< int >(val2);
15597 {
15598 PyThreadState* __tstate = wxPyBeginAllowThreads();
15599 (arg1)->SetZPosition(arg2);
15600 wxPyEndAllowThreads(__tstate);
15601 if (PyErr_Occurred()) SWIG_fail;
15602 }
15603 resultobj = SWIG_Py_Void();
15604 return resultobj;
15605 fail:
15606 return NULL;
15607 }
15608
15609
15610 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15611 PyObject *resultobj = 0;
15612 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15613 bool result;
15614 void *argp1 = 0 ;
15615 int res1 = 0 ;
15616 PyObject *swig_obj[1] ;
15617
15618 if (!args) SWIG_fail;
15619 swig_obj[0] = args;
15620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15621 if (!SWIG_IsOK(res1)) {
15622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15623 }
15624 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15625 {
15626 PyThreadState* __tstate = wxPyBeginAllowThreads();
15627 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15628 wxPyEndAllowThreads(__tstate);
15629 if (PyErr_Occurred()) SWIG_fail;
15630 }
15631 {
15632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15633 }
15634 return resultobj;
15635 fail:
15636 return NULL;
15637 }
15638
15639
15640 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15641 PyObject *resultobj = 0;
15642 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15643 bool result;
15644 void *argp1 = 0 ;
15645 int res1 = 0 ;
15646 PyObject *swig_obj[1] ;
15647
15648 if (!args) SWIG_fail;
15649 swig_obj[0] = args;
15650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15651 if (!SWIG_IsOK(res1)) {
15652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15653 }
15654 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15655 {
15656 PyThreadState* __tstate = wxPyBeginAllowThreads();
15657 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15658 wxPyEndAllowThreads(__tstate);
15659 if (PyErr_Occurred()) SWIG_fail;
15660 }
15661 {
15662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15663 }
15664 return resultobj;
15665 fail:
15666 return NULL;
15667 }
15668
15669
15670 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15671 PyObject *resultobj = 0;
15672 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15673 bool result;
15674 void *argp1 = 0 ;
15675 int res1 = 0 ;
15676 PyObject *swig_obj[1] ;
15677
15678 if (!args) SWIG_fail;
15679 swig_obj[0] = args;
15680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15681 if (!SWIG_IsOK(res1)) {
15682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15683 }
15684 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 {
15692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15693 }
15694 return resultobj;
15695 fail:
15696 return NULL;
15697 }
15698
15699
15700 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15701 PyObject *resultobj = 0;
15702 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15703 int arg2 = (int) wxJOY_BUTTON_ANY ;
15704 bool result;
15705 void *argp1 = 0 ;
15706 int res1 = 0 ;
15707 int val2 ;
15708 int ecode2 = 0 ;
15709 PyObject * obj0 = 0 ;
15710 PyObject * obj1 = 0 ;
15711 char * kwnames[] = {
15712 (char *) "self",(char *) "but", NULL
15713 };
15714
15715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15717 if (!SWIG_IsOK(res1)) {
15718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15719 }
15720 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15721 if (obj1) {
15722 ecode2 = SWIG_AsVal_int(obj1, &val2);
15723 if (!SWIG_IsOK(ecode2)) {
15724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15725 }
15726 arg2 = static_cast< int >(val2);
15727 }
15728 {
15729 PyThreadState* __tstate = wxPyBeginAllowThreads();
15730 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15731 wxPyEndAllowThreads(__tstate);
15732 if (PyErr_Occurred()) SWIG_fail;
15733 }
15734 {
15735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15736 }
15737 return resultobj;
15738 fail:
15739 return NULL;
15740 }
15741
15742
15743 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15744 PyObject *resultobj = 0;
15745 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15746 int arg2 = (int) wxJOY_BUTTON_ANY ;
15747 bool result;
15748 void *argp1 = 0 ;
15749 int res1 = 0 ;
15750 int val2 ;
15751 int ecode2 = 0 ;
15752 PyObject * obj0 = 0 ;
15753 PyObject * obj1 = 0 ;
15754 char * kwnames[] = {
15755 (char *) "self",(char *) "but", NULL
15756 };
15757
15758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15760 if (!SWIG_IsOK(res1)) {
15761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15762 }
15763 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15764 if (obj1) {
15765 ecode2 = SWIG_AsVal_int(obj1, &val2);
15766 if (!SWIG_IsOK(ecode2)) {
15767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15768 }
15769 arg2 = static_cast< int >(val2);
15770 }
15771 {
15772 PyThreadState* __tstate = wxPyBeginAllowThreads();
15773 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15774 wxPyEndAllowThreads(__tstate);
15775 if (PyErr_Occurred()) SWIG_fail;
15776 }
15777 {
15778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15779 }
15780 return resultobj;
15781 fail:
15782 return NULL;
15783 }
15784
15785
15786 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15787 PyObject *resultobj = 0;
15788 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15789 int arg2 = (int) wxJOY_BUTTON_ANY ;
15790 bool result;
15791 void *argp1 = 0 ;
15792 int res1 = 0 ;
15793 int val2 ;
15794 int ecode2 = 0 ;
15795 PyObject * obj0 = 0 ;
15796 PyObject * obj1 = 0 ;
15797 char * kwnames[] = {
15798 (char *) "self",(char *) "but", NULL
15799 };
15800
15801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15803 if (!SWIG_IsOK(res1)) {
15804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15805 }
15806 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15807 if (obj1) {
15808 ecode2 = SWIG_AsVal_int(obj1, &val2);
15809 if (!SWIG_IsOK(ecode2)) {
15810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15811 }
15812 arg2 = static_cast< int >(val2);
15813 }
15814 {
15815 PyThreadState* __tstate = wxPyBeginAllowThreads();
15816 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15817 wxPyEndAllowThreads(__tstate);
15818 if (PyErr_Occurred()) SWIG_fail;
15819 }
15820 {
15821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15822 }
15823 return resultobj;
15824 fail:
15825 return NULL;
15826 }
15827
15828
15829 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15830 PyObject *obj;
15831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15832 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15833 return SWIG_Py_Void();
15834 }
15835
15836 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15837 return SWIG_Python_InitShadowInstance(args);
15838 }
15839
15840 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15841 PyObject *resultobj = 0;
15842 wxString const &arg1_defvalue = wxPyEmptyString ;
15843 wxString *arg1 = (wxString *) &arg1_defvalue ;
15844 wxSound *result = 0 ;
15845 bool temp1 = false ;
15846 PyObject * obj0 = 0 ;
15847 char * kwnames[] = {
15848 (char *) "fileName", NULL
15849 };
15850
15851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15852 if (obj0) {
15853 {
15854 arg1 = wxString_in_helper(obj0);
15855 if (arg1 == NULL) SWIG_fail;
15856 temp1 = true;
15857 }
15858 }
15859 {
15860 if (!wxPyCheckForApp()) SWIG_fail;
15861 PyThreadState* __tstate = wxPyBeginAllowThreads();
15862 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15863 wxPyEndAllowThreads(__tstate);
15864 if (PyErr_Occurred()) SWIG_fail;
15865 }
15866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15867 {
15868 if (temp1)
15869 delete arg1;
15870 }
15871 return resultobj;
15872 fail:
15873 {
15874 if (temp1)
15875 delete arg1;
15876 }
15877 return NULL;
15878 }
15879
15880
15881 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15882 PyObject *resultobj = 0;
15883 PyObject *arg1 = (PyObject *) 0 ;
15884 wxSound *result = 0 ;
15885 PyObject * obj0 = 0 ;
15886 char * kwnames[] = {
15887 (char *) "data", NULL
15888 };
15889
15890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15891 arg1 = obj0;
15892 {
15893 if (!wxPyCheckForApp()) SWIG_fail;
15894 PyThreadState* __tstate = wxPyBeginAllowThreads();
15895 result = (wxSound *)new_wxSound(arg1);
15896 wxPyEndAllowThreads(__tstate);
15897 if (PyErr_Occurred()) SWIG_fail;
15898 }
15899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15900 return resultobj;
15901 fail:
15902 return NULL;
15903 }
15904
15905
15906 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15907 PyObject *resultobj = 0;
15908 wxSound *arg1 = (wxSound *) 0 ;
15909 void *argp1 = 0 ;
15910 int res1 = 0 ;
15911 PyObject *swig_obj[1] ;
15912
15913 if (!args) SWIG_fail;
15914 swig_obj[0] = args;
15915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15916 if (!SWIG_IsOK(res1)) {
15917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15918 }
15919 arg1 = reinterpret_cast< wxSound * >(argp1);
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 delete arg1;
15923
15924 wxPyEndAllowThreads(__tstate);
15925 if (PyErr_Occurred()) SWIG_fail;
15926 }
15927 resultobj = SWIG_Py_Void();
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15935 PyObject *resultobj = 0;
15936 wxSound *arg1 = (wxSound *) 0 ;
15937 wxString *arg2 = 0 ;
15938 bool result;
15939 void *argp1 = 0 ;
15940 int res1 = 0 ;
15941 bool temp2 = false ;
15942 PyObject * obj0 = 0 ;
15943 PyObject * obj1 = 0 ;
15944 char * kwnames[] = {
15945 (char *) "self",(char *) "fileName", NULL
15946 };
15947
15948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15950 if (!SWIG_IsOK(res1)) {
15951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15952 }
15953 arg1 = reinterpret_cast< wxSound * >(argp1);
15954 {
15955 arg2 = wxString_in_helper(obj1);
15956 if (arg2 == NULL) SWIG_fail;
15957 temp2 = true;
15958 }
15959 {
15960 PyThreadState* __tstate = wxPyBeginAllowThreads();
15961 result = (bool)(arg1)->Create((wxString const &)*arg2);
15962 wxPyEndAllowThreads(__tstate);
15963 if (PyErr_Occurred()) SWIG_fail;
15964 }
15965 {
15966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15967 }
15968 {
15969 if (temp2)
15970 delete arg2;
15971 }
15972 return resultobj;
15973 fail:
15974 {
15975 if (temp2)
15976 delete arg2;
15977 }
15978 return NULL;
15979 }
15980
15981
15982 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15983 PyObject *resultobj = 0;
15984 wxSound *arg1 = (wxSound *) 0 ;
15985 PyObject *arg2 = (PyObject *) 0 ;
15986 bool result;
15987 void *argp1 = 0 ;
15988 int res1 = 0 ;
15989 PyObject * obj0 = 0 ;
15990 PyObject * obj1 = 0 ;
15991 char * kwnames[] = {
15992 (char *) "self",(char *) "data", NULL
15993 };
15994
15995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
15996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15997 if (!SWIG_IsOK(res1)) {
15998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
15999 }
16000 arg1 = reinterpret_cast< wxSound * >(argp1);
16001 arg2 = obj1;
16002 {
16003 PyThreadState* __tstate = wxPyBeginAllowThreads();
16004 result = (bool)wxSound_CreateFromData(arg1,arg2);
16005 wxPyEndAllowThreads(__tstate);
16006 if (PyErr_Occurred()) SWIG_fail;
16007 }
16008 {
16009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16010 }
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16018 PyObject *resultobj = 0;
16019 wxSound *arg1 = (wxSound *) 0 ;
16020 bool result;
16021 void *argp1 = 0 ;
16022 int res1 = 0 ;
16023 PyObject *swig_obj[1] ;
16024
16025 if (!args) SWIG_fail;
16026 swig_obj[0] = args;
16027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16028 if (!SWIG_IsOK(res1)) {
16029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16030 }
16031 arg1 = reinterpret_cast< wxSound * >(argp1);
16032 {
16033 PyThreadState* __tstate = wxPyBeginAllowThreads();
16034 result = (bool)(arg1)->IsOk();
16035 wxPyEndAllowThreads(__tstate);
16036 if (PyErr_Occurred()) SWIG_fail;
16037 }
16038 {
16039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16040 }
16041 return resultobj;
16042 fail:
16043 return NULL;
16044 }
16045
16046
16047 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16048 PyObject *resultobj = 0;
16049 wxSound *arg1 = (wxSound *) 0 ;
16050 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16051 bool result;
16052 void *argp1 = 0 ;
16053 int res1 = 0 ;
16054 unsigned int val2 ;
16055 int ecode2 = 0 ;
16056 PyObject * obj0 = 0 ;
16057 PyObject * obj1 = 0 ;
16058 char * kwnames[] = {
16059 (char *) "self",(char *) "flags", NULL
16060 };
16061
16062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16064 if (!SWIG_IsOK(res1)) {
16065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16066 }
16067 arg1 = reinterpret_cast< wxSound * >(argp1);
16068 if (obj1) {
16069 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16070 if (!SWIG_IsOK(ecode2)) {
16071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16072 }
16073 arg2 = static_cast< unsigned int >(val2);
16074 }
16075 {
16076 if (!wxPyCheckForApp()) SWIG_fail;
16077 PyThreadState* __tstate = wxPyBeginAllowThreads();
16078 result = (bool)((wxSound const *)arg1)->Play(arg2);
16079 wxPyEndAllowThreads(__tstate);
16080 if (PyErr_Occurred()) SWIG_fail;
16081 }
16082 {
16083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16084 }
16085 return resultobj;
16086 fail:
16087 return NULL;
16088 }
16089
16090
16091 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16092 PyObject *resultobj = 0;
16093 wxString *arg1 = 0 ;
16094 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16095 bool result;
16096 bool temp1 = false ;
16097 unsigned int val2 ;
16098 int ecode2 = 0 ;
16099 PyObject * obj0 = 0 ;
16100 PyObject * obj1 = 0 ;
16101 char * kwnames[] = {
16102 (char *) "filename",(char *) "flags", NULL
16103 };
16104
16105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16106 {
16107 arg1 = wxString_in_helper(obj0);
16108 if (arg1 == NULL) SWIG_fail;
16109 temp1 = true;
16110 }
16111 if (obj1) {
16112 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16113 if (!SWIG_IsOK(ecode2)) {
16114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16115 }
16116 arg2 = static_cast< unsigned int >(val2);
16117 }
16118 {
16119 if (!wxPyCheckForApp()) SWIG_fail;
16120 PyThreadState* __tstate = wxPyBeginAllowThreads();
16121 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16122 wxPyEndAllowThreads(__tstate);
16123 if (PyErr_Occurred()) SWIG_fail;
16124 }
16125 {
16126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16127 }
16128 {
16129 if (temp1)
16130 delete arg1;
16131 }
16132 return resultobj;
16133 fail:
16134 {
16135 if (temp1)
16136 delete arg1;
16137 }
16138 return NULL;
16139 }
16140
16141
16142 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16143 PyObject *resultobj = 0;
16144
16145 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16146 {
16147 if (!wxPyCheckForApp()) SWIG_fail;
16148 PyThreadState* __tstate = wxPyBeginAllowThreads();
16149 wxSound::Stop();
16150 wxPyEndAllowThreads(__tstate);
16151 if (PyErr_Occurred()) SWIG_fail;
16152 }
16153 resultobj = SWIG_Py_Void();
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16161 PyObject *obj;
16162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16163 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16164 return SWIG_Py_Void();
16165 }
16166
16167 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16168 return SWIG_Python_InitShadowInstance(args);
16169 }
16170
16171 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16172 PyObject *resultobj = 0;
16173 wxString *arg1 = 0 ;
16174 wxString *arg2 = 0 ;
16175 wxString *arg3 = 0 ;
16176 wxString *arg4 = 0 ;
16177 wxFileTypeInfo *result = 0 ;
16178 bool temp1 = false ;
16179 bool temp2 = false ;
16180 bool temp3 = false ;
16181 bool temp4 = false ;
16182 PyObject * obj0 = 0 ;
16183 PyObject * obj1 = 0 ;
16184 PyObject * obj2 = 0 ;
16185 PyObject * obj3 = 0 ;
16186 char * kwnames[] = {
16187 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16188 };
16189
16190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16191 {
16192 arg1 = wxString_in_helper(obj0);
16193 if (arg1 == NULL) SWIG_fail;
16194 temp1 = true;
16195 }
16196 {
16197 arg2 = wxString_in_helper(obj1);
16198 if (arg2 == NULL) SWIG_fail;
16199 temp2 = true;
16200 }
16201 {
16202 arg3 = wxString_in_helper(obj2);
16203 if (arg3 == NULL) SWIG_fail;
16204 temp3 = true;
16205 }
16206 {
16207 arg4 = wxString_in_helper(obj3);
16208 if (arg4 == NULL) SWIG_fail;
16209 temp4 = true;
16210 }
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16214 wxPyEndAllowThreads(__tstate);
16215 if (PyErr_Occurred()) SWIG_fail;
16216 }
16217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16218 {
16219 if (temp1)
16220 delete arg1;
16221 }
16222 {
16223 if (temp2)
16224 delete arg2;
16225 }
16226 {
16227 if (temp3)
16228 delete arg3;
16229 }
16230 {
16231 if (temp4)
16232 delete arg4;
16233 }
16234 return resultobj;
16235 fail:
16236 {
16237 if (temp1)
16238 delete arg1;
16239 }
16240 {
16241 if (temp2)
16242 delete arg2;
16243 }
16244 {
16245 if (temp3)
16246 delete arg3;
16247 }
16248 {
16249 if (temp4)
16250 delete arg4;
16251 }
16252 return NULL;
16253 }
16254
16255
16256 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16257 PyObject *resultobj = 0;
16258 wxArrayString *arg1 = 0 ;
16259 wxFileTypeInfo *result = 0 ;
16260 bool temp1 = false ;
16261 PyObject * obj0 = 0 ;
16262 char * kwnames[] = {
16263 (char *) "sArray", NULL
16264 };
16265
16266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16267 {
16268 if (! PySequence_Check(obj0)) {
16269 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16270 SWIG_fail;
16271 }
16272 arg1 = new wxArrayString;
16273 temp1 = true;
16274 int i, len=PySequence_Length(obj0);
16275 for (i=0; i<len; i++) {
16276 PyObject* item = PySequence_GetItem(obj0, i);
16277 wxString* s = wxString_in_helper(item);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 arg1->Add(*s);
16280 delete s;
16281 Py_DECREF(item);
16282 }
16283 }
16284 {
16285 PyThreadState* __tstate = wxPyBeginAllowThreads();
16286 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16287 wxPyEndAllowThreads(__tstate);
16288 if (PyErr_Occurred()) SWIG_fail;
16289 }
16290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16291 {
16292 if (temp1) delete arg1;
16293 }
16294 return resultobj;
16295 fail:
16296 {
16297 if (temp1) delete arg1;
16298 }
16299 return NULL;
16300 }
16301
16302
16303 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16304 PyObject *resultobj = 0;
16305 wxFileTypeInfo *result = 0 ;
16306
16307 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16308 {
16309 PyThreadState* __tstate = wxPyBeginAllowThreads();
16310 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16311 wxPyEndAllowThreads(__tstate);
16312 if (PyErr_Occurred()) SWIG_fail;
16313 }
16314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16315 return resultobj;
16316 fail:
16317 return NULL;
16318 }
16319
16320
16321 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16322 PyObject *resultobj = 0;
16323 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16324 bool result;
16325 void *argp1 = 0 ;
16326 int res1 = 0 ;
16327 PyObject *swig_obj[1] ;
16328
16329 if (!args) SWIG_fail;
16330 swig_obj[0] = args;
16331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16332 if (!SWIG_IsOK(res1)) {
16333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16334 }
16335 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16336 {
16337 PyThreadState* __tstate = wxPyBeginAllowThreads();
16338 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 {
16343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16344 }
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj = 0;
16353 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16354 wxString *arg2 = 0 ;
16355 int arg3 = (int) 0 ;
16356 void *argp1 = 0 ;
16357 int res1 = 0 ;
16358 bool temp2 = false ;
16359 int val3 ;
16360 int ecode3 = 0 ;
16361 PyObject * obj0 = 0 ;
16362 PyObject * obj1 = 0 ;
16363 PyObject * obj2 = 0 ;
16364 char * kwnames[] = {
16365 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16366 };
16367
16368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16370 if (!SWIG_IsOK(res1)) {
16371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16372 }
16373 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16374 {
16375 arg2 = wxString_in_helper(obj1);
16376 if (arg2 == NULL) SWIG_fail;
16377 temp2 = true;
16378 }
16379 if (obj2) {
16380 ecode3 = SWIG_AsVal_int(obj2, &val3);
16381 if (!SWIG_IsOK(ecode3)) {
16382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16383 }
16384 arg3 = static_cast< int >(val3);
16385 }
16386 {
16387 PyThreadState* __tstate = wxPyBeginAllowThreads();
16388 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16389 wxPyEndAllowThreads(__tstate);
16390 if (PyErr_Occurred()) SWIG_fail;
16391 }
16392 resultobj = SWIG_Py_Void();
16393 {
16394 if (temp2)
16395 delete arg2;
16396 }
16397 return resultobj;
16398 fail:
16399 {
16400 if (temp2)
16401 delete arg2;
16402 }
16403 return NULL;
16404 }
16405
16406
16407 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj = 0;
16409 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16410 wxString *arg2 = 0 ;
16411 void *argp1 = 0 ;
16412 int res1 = 0 ;
16413 bool temp2 = false ;
16414 PyObject * obj0 = 0 ;
16415 PyObject * obj1 = 0 ;
16416 char * kwnames[] = {
16417 (char *) "self",(char *) "shortDesc", NULL
16418 };
16419
16420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16422 if (!SWIG_IsOK(res1)) {
16423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16424 }
16425 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16426 {
16427 arg2 = wxString_in_helper(obj1);
16428 if (arg2 == NULL) SWIG_fail;
16429 temp2 = true;
16430 }
16431 {
16432 PyThreadState* __tstate = wxPyBeginAllowThreads();
16433 (arg1)->SetShortDesc((wxString const &)*arg2);
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 resultobj = SWIG_Py_Void();
16438 {
16439 if (temp2)
16440 delete arg2;
16441 }
16442 return resultobj;
16443 fail:
16444 {
16445 if (temp2)
16446 delete arg2;
16447 }
16448 return NULL;
16449 }
16450
16451
16452 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16453 PyObject *resultobj = 0;
16454 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16455 wxString *result = 0 ;
16456 void *argp1 = 0 ;
16457 int res1 = 0 ;
16458 PyObject *swig_obj[1] ;
16459
16460 if (!args) SWIG_fail;
16461 swig_obj[0] = args;
16462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16463 if (!SWIG_IsOK(res1)) {
16464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16465 }
16466 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16467 {
16468 PyThreadState* __tstate = wxPyBeginAllowThreads();
16469 {
16470 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16471 result = (wxString *) &_result_ref;
16472 }
16473 wxPyEndAllowThreads(__tstate);
16474 if (PyErr_Occurred()) SWIG_fail;
16475 }
16476 {
16477 #if wxUSE_UNICODE
16478 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16479 #else
16480 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16481 #endif
16482 }
16483 return resultobj;
16484 fail:
16485 return NULL;
16486 }
16487
16488
16489 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16490 PyObject *resultobj = 0;
16491 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16492 wxString *result = 0 ;
16493 void *argp1 = 0 ;
16494 int res1 = 0 ;
16495 PyObject *swig_obj[1] ;
16496
16497 if (!args) SWIG_fail;
16498 swig_obj[0] = args;
16499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16500 if (!SWIG_IsOK(res1)) {
16501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16502 }
16503 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16504 {
16505 PyThreadState* __tstate = wxPyBeginAllowThreads();
16506 {
16507 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16508 result = (wxString *) &_result_ref;
16509 }
16510 wxPyEndAllowThreads(__tstate);
16511 if (PyErr_Occurred()) SWIG_fail;
16512 }
16513 {
16514 #if wxUSE_UNICODE
16515 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16516 #else
16517 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16518 #endif
16519 }
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16527 PyObject *resultobj = 0;
16528 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16529 wxString *result = 0 ;
16530 void *argp1 = 0 ;
16531 int res1 = 0 ;
16532 PyObject *swig_obj[1] ;
16533
16534 if (!args) SWIG_fail;
16535 swig_obj[0] = args;
16536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16537 if (!SWIG_IsOK(res1)) {
16538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16539 }
16540 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16541 {
16542 PyThreadState* __tstate = wxPyBeginAllowThreads();
16543 {
16544 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16545 result = (wxString *) &_result_ref;
16546 }
16547 wxPyEndAllowThreads(__tstate);
16548 if (PyErr_Occurred()) SWIG_fail;
16549 }
16550 {
16551 #if wxUSE_UNICODE
16552 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16553 #else
16554 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16555 #endif
16556 }
16557 return resultobj;
16558 fail:
16559 return NULL;
16560 }
16561
16562
16563 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16564 PyObject *resultobj = 0;
16565 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16566 wxString *result = 0 ;
16567 void *argp1 = 0 ;
16568 int res1 = 0 ;
16569 PyObject *swig_obj[1] ;
16570
16571 if (!args) SWIG_fail;
16572 swig_obj[0] = args;
16573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16574 if (!SWIG_IsOK(res1)) {
16575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16576 }
16577 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16578 {
16579 PyThreadState* __tstate = wxPyBeginAllowThreads();
16580 {
16581 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16582 result = (wxString *) &_result_ref;
16583 }
16584 wxPyEndAllowThreads(__tstate);
16585 if (PyErr_Occurred()) SWIG_fail;
16586 }
16587 {
16588 #if wxUSE_UNICODE
16589 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16590 #else
16591 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16592 #endif
16593 }
16594 return resultobj;
16595 fail:
16596 return NULL;
16597 }
16598
16599
16600 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16601 PyObject *resultobj = 0;
16602 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16603 wxString *result = 0 ;
16604 void *argp1 = 0 ;
16605 int res1 = 0 ;
16606 PyObject *swig_obj[1] ;
16607
16608 if (!args) SWIG_fail;
16609 swig_obj[0] = args;
16610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16611 if (!SWIG_IsOK(res1)) {
16612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16613 }
16614 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16615 {
16616 PyThreadState* __tstate = wxPyBeginAllowThreads();
16617 {
16618 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16619 result = (wxString *) &_result_ref;
16620 }
16621 wxPyEndAllowThreads(__tstate);
16622 if (PyErr_Occurred()) SWIG_fail;
16623 }
16624 {
16625 #if wxUSE_UNICODE
16626 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16627 #else
16628 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16629 #endif
16630 }
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16638 PyObject *resultobj = 0;
16639 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16640 wxArrayString *result = 0 ;
16641 void *argp1 = 0 ;
16642 int res1 = 0 ;
16643 PyObject *swig_obj[1] ;
16644
16645 if (!args) SWIG_fail;
16646 swig_obj[0] = args;
16647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16648 if (!SWIG_IsOK(res1)) {
16649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16650 }
16651 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 {
16655 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16656 result = (wxArrayString *) &_result_ref;
16657 }
16658 wxPyEndAllowThreads(__tstate);
16659 if (PyErr_Occurred()) SWIG_fail;
16660 }
16661 {
16662 resultobj = wxArrayString2PyList_helper(*result);
16663 }
16664 return resultobj;
16665 fail:
16666 return NULL;
16667 }
16668
16669
16670 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16671 PyObject *resultobj = 0;
16672 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16673 size_t result;
16674 void *argp1 = 0 ;
16675 int res1 = 0 ;
16676 PyObject *swig_obj[1] ;
16677
16678 if (!args) SWIG_fail;
16679 swig_obj[0] = args;
16680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16681 if (!SWIG_IsOK(res1)) {
16682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16683 }
16684 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16685 {
16686 PyThreadState* __tstate = wxPyBeginAllowThreads();
16687 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16688 wxPyEndAllowThreads(__tstate);
16689 if (PyErr_Occurred()) SWIG_fail;
16690 }
16691 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16692 return resultobj;
16693 fail:
16694 return NULL;
16695 }
16696
16697
16698 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16699 PyObject *resultobj = 0;
16700 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16701 wxString *result = 0 ;
16702 void *argp1 = 0 ;
16703 int res1 = 0 ;
16704 PyObject *swig_obj[1] ;
16705
16706 if (!args) SWIG_fail;
16707 swig_obj[0] = args;
16708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16709 if (!SWIG_IsOK(res1)) {
16710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16711 }
16712 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16713 {
16714 PyThreadState* __tstate = wxPyBeginAllowThreads();
16715 {
16716 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16717 result = (wxString *) &_result_ref;
16718 }
16719 wxPyEndAllowThreads(__tstate);
16720 if (PyErr_Occurred()) SWIG_fail;
16721 }
16722 {
16723 #if wxUSE_UNICODE
16724 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16725 #else
16726 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16727 #endif
16728 }
16729 return resultobj;
16730 fail:
16731 return NULL;
16732 }
16733
16734
16735 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16736 PyObject *resultobj = 0;
16737 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16738 int result;
16739 void *argp1 = 0 ;
16740 int res1 = 0 ;
16741 PyObject *swig_obj[1] ;
16742
16743 if (!args) SWIG_fail;
16744 swig_obj[0] = args;
16745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16746 if (!SWIG_IsOK(res1)) {
16747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16748 }
16749 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16750 {
16751 PyThreadState* __tstate = wxPyBeginAllowThreads();
16752 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16753 wxPyEndAllowThreads(__tstate);
16754 if (PyErr_Occurred()) SWIG_fail;
16755 }
16756 resultobj = SWIG_From_int(static_cast< int >(result));
16757 return resultobj;
16758 fail:
16759 return NULL;
16760 }
16761
16762
16763 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16764 PyObject *obj;
16765 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16766 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16767 return SWIG_Py_Void();
16768 }
16769
16770 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16771 return SWIG_Python_InitShadowInstance(args);
16772 }
16773
16774 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16775 PyObject *resultobj = 0;
16776 wxFileTypeInfo *arg1 = 0 ;
16777 wxFileType *result = 0 ;
16778 void *argp1 = 0 ;
16779 int res1 = 0 ;
16780 PyObject * obj0 = 0 ;
16781 char * kwnames[] = {
16782 (char *) "ftInfo", NULL
16783 };
16784
16785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16786 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16787 if (!SWIG_IsOK(res1)) {
16788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16789 }
16790 if (!argp1) {
16791 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16792 }
16793 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16794 {
16795 PyThreadState* __tstate = wxPyBeginAllowThreads();
16796 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16797 wxPyEndAllowThreads(__tstate);
16798 if (PyErr_Occurred()) SWIG_fail;
16799 }
16800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16801 return resultobj;
16802 fail:
16803 return NULL;
16804 }
16805
16806
16807 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16808 PyObject *resultobj = 0;
16809 wxFileType *arg1 = (wxFileType *) 0 ;
16810 void *argp1 = 0 ;
16811 int res1 = 0 ;
16812 PyObject *swig_obj[1] ;
16813
16814 if (!args) SWIG_fail;
16815 swig_obj[0] = args;
16816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16817 if (!SWIG_IsOK(res1)) {
16818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16819 }
16820 arg1 = reinterpret_cast< wxFileType * >(argp1);
16821 {
16822 PyThreadState* __tstate = wxPyBeginAllowThreads();
16823 delete arg1;
16824
16825 wxPyEndAllowThreads(__tstate);
16826 if (PyErr_Occurred()) SWIG_fail;
16827 }
16828 resultobj = SWIG_Py_Void();
16829 return resultobj;
16830 fail:
16831 return NULL;
16832 }
16833
16834
16835 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16836 PyObject *resultobj = 0;
16837 wxFileType *arg1 = (wxFileType *) 0 ;
16838 PyObject *result = 0 ;
16839 void *argp1 = 0 ;
16840 int res1 = 0 ;
16841 PyObject *swig_obj[1] ;
16842
16843 if (!args) SWIG_fail;
16844 swig_obj[0] = args;
16845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16846 if (!SWIG_IsOK(res1)) {
16847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16848 }
16849 arg1 = reinterpret_cast< wxFileType * >(argp1);
16850 {
16851 PyThreadState* __tstate = wxPyBeginAllowThreads();
16852 result = (PyObject *)wxFileType_GetMimeType(arg1);
16853 wxPyEndAllowThreads(__tstate);
16854 if (PyErr_Occurred()) SWIG_fail;
16855 }
16856 resultobj = result;
16857 return resultobj;
16858 fail:
16859 return NULL;
16860 }
16861
16862
16863 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16864 PyObject *resultobj = 0;
16865 wxFileType *arg1 = (wxFileType *) 0 ;
16866 PyObject *result = 0 ;
16867 void *argp1 = 0 ;
16868 int res1 = 0 ;
16869 PyObject *swig_obj[1] ;
16870
16871 if (!args) SWIG_fail;
16872 swig_obj[0] = args;
16873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16874 if (!SWIG_IsOK(res1)) {
16875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16876 }
16877 arg1 = reinterpret_cast< wxFileType * >(argp1);
16878 {
16879 PyThreadState* __tstate = wxPyBeginAllowThreads();
16880 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16881 wxPyEndAllowThreads(__tstate);
16882 if (PyErr_Occurred()) SWIG_fail;
16883 }
16884 resultobj = result;
16885 return resultobj;
16886 fail:
16887 return NULL;
16888 }
16889
16890
16891 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16892 PyObject *resultobj = 0;
16893 wxFileType *arg1 = (wxFileType *) 0 ;
16894 PyObject *result = 0 ;
16895 void *argp1 = 0 ;
16896 int res1 = 0 ;
16897 PyObject *swig_obj[1] ;
16898
16899 if (!args) SWIG_fail;
16900 swig_obj[0] = args;
16901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16902 if (!SWIG_IsOK(res1)) {
16903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16904 }
16905 arg1 = reinterpret_cast< wxFileType * >(argp1);
16906 {
16907 PyThreadState* __tstate = wxPyBeginAllowThreads();
16908 result = (PyObject *)wxFileType_GetExtensions(arg1);
16909 wxPyEndAllowThreads(__tstate);
16910 if (PyErr_Occurred()) SWIG_fail;
16911 }
16912 resultobj = result;
16913 return resultobj;
16914 fail:
16915 return NULL;
16916 }
16917
16918
16919 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16920 PyObject *resultobj = 0;
16921 wxFileType *arg1 = (wxFileType *) 0 ;
16922 wxIcon *result = 0 ;
16923 void *argp1 = 0 ;
16924 int res1 = 0 ;
16925 PyObject *swig_obj[1] ;
16926
16927 if (!args) SWIG_fail;
16928 swig_obj[0] = args;
16929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16930 if (!SWIG_IsOK(res1)) {
16931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16932 }
16933 arg1 = reinterpret_cast< wxFileType * >(argp1);
16934 {
16935 PyThreadState* __tstate = wxPyBeginAllowThreads();
16936 result = (wxIcon *)wxFileType_GetIcon(arg1);
16937 wxPyEndAllowThreads(__tstate);
16938 if (PyErr_Occurred()) SWIG_fail;
16939 }
16940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16941 return resultobj;
16942 fail:
16943 return NULL;
16944 }
16945
16946
16947 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16948 PyObject *resultobj = 0;
16949 wxFileType *arg1 = (wxFileType *) 0 ;
16950 PyObject *result = 0 ;
16951 void *argp1 = 0 ;
16952 int res1 = 0 ;
16953 PyObject *swig_obj[1] ;
16954
16955 if (!args) SWIG_fail;
16956 swig_obj[0] = args;
16957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16958 if (!SWIG_IsOK(res1)) {
16959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16960 }
16961 arg1 = reinterpret_cast< wxFileType * >(argp1);
16962 {
16963 PyThreadState* __tstate = wxPyBeginAllowThreads();
16964 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16965 wxPyEndAllowThreads(__tstate);
16966 if (PyErr_Occurred()) SWIG_fail;
16967 }
16968 resultobj = result;
16969 return resultobj;
16970 fail:
16971 return NULL;
16972 }
16973
16974
16975 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16976 PyObject *resultobj = 0;
16977 wxFileType *arg1 = (wxFileType *) 0 ;
16978 PyObject *result = 0 ;
16979 void *argp1 = 0 ;
16980 int res1 = 0 ;
16981 PyObject *swig_obj[1] ;
16982
16983 if (!args) SWIG_fail;
16984 swig_obj[0] = args;
16985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16986 if (!SWIG_IsOK(res1)) {
16987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16988 }
16989 arg1 = reinterpret_cast< wxFileType * >(argp1);
16990 {
16991 PyThreadState* __tstate = wxPyBeginAllowThreads();
16992 result = (PyObject *)wxFileType_GetDescription(arg1);
16993 wxPyEndAllowThreads(__tstate);
16994 if (PyErr_Occurred()) SWIG_fail;
16995 }
16996 resultobj = result;
16997 return resultobj;
16998 fail:
16999 return NULL;
17000 }
17001
17002
17003 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17004 PyObject *resultobj = 0;
17005 wxFileType *arg1 = (wxFileType *) 0 ;
17006 wxString *arg2 = 0 ;
17007 wxString const &arg3_defvalue = wxPyEmptyString ;
17008 wxString *arg3 = (wxString *) &arg3_defvalue ;
17009 PyObject *result = 0 ;
17010 void *argp1 = 0 ;
17011 int res1 = 0 ;
17012 bool temp2 = false ;
17013 bool temp3 = false ;
17014 PyObject * obj0 = 0 ;
17015 PyObject * obj1 = 0 ;
17016 PyObject * obj2 = 0 ;
17017 char * kwnames[] = {
17018 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17019 };
17020
17021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17023 if (!SWIG_IsOK(res1)) {
17024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17025 }
17026 arg1 = reinterpret_cast< wxFileType * >(argp1);
17027 {
17028 arg2 = wxString_in_helper(obj1);
17029 if (arg2 == NULL) SWIG_fail;
17030 temp2 = true;
17031 }
17032 if (obj2) {
17033 {
17034 arg3 = wxString_in_helper(obj2);
17035 if (arg3 == NULL) SWIG_fail;
17036 temp3 = true;
17037 }
17038 }
17039 {
17040 PyThreadState* __tstate = wxPyBeginAllowThreads();
17041 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17042 wxPyEndAllowThreads(__tstate);
17043 if (PyErr_Occurred()) SWIG_fail;
17044 }
17045 resultobj = result;
17046 {
17047 if (temp2)
17048 delete arg2;
17049 }
17050 {
17051 if (temp3)
17052 delete arg3;
17053 }
17054 return resultobj;
17055 fail:
17056 {
17057 if (temp2)
17058 delete arg2;
17059 }
17060 {
17061 if (temp3)
17062 delete arg3;
17063 }
17064 return NULL;
17065 }
17066
17067
17068 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17069 PyObject *resultobj = 0;
17070 wxFileType *arg1 = (wxFileType *) 0 ;
17071 wxString *arg2 = 0 ;
17072 wxString const &arg3_defvalue = wxPyEmptyString ;
17073 wxString *arg3 = (wxString *) &arg3_defvalue ;
17074 PyObject *result = 0 ;
17075 void *argp1 = 0 ;
17076 int res1 = 0 ;
17077 bool temp2 = false ;
17078 bool temp3 = false ;
17079 PyObject * obj0 = 0 ;
17080 PyObject * obj1 = 0 ;
17081 PyObject * obj2 = 0 ;
17082 char * kwnames[] = {
17083 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17084 };
17085
17086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17088 if (!SWIG_IsOK(res1)) {
17089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17090 }
17091 arg1 = reinterpret_cast< wxFileType * >(argp1);
17092 {
17093 arg2 = wxString_in_helper(obj1);
17094 if (arg2 == NULL) SWIG_fail;
17095 temp2 = true;
17096 }
17097 if (obj2) {
17098 {
17099 arg3 = wxString_in_helper(obj2);
17100 if (arg3 == NULL) SWIG_fail;
17101 temp3 = true;
17102 }
17103 }
17104 {
17105 PyThreadState* __tstate = wxPyBeginAllowThreads();
17106 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17107 wxPyEndAllowThreads(__tstate);
17108 if (PyErr_Occurred()) SWIG_fail;
17109 }
17110 resultobj = result;
17111 {
17112 if (temp2)
17113 delete arg2;
17114 }
17115 {
17116 if (temp3)
17117 delete arg3;
17118 }
17119 return resultobj;
17120 fail:
17121 {
17122 if (temp2)
17123 delete arg2;
17124 }
17125 {
17126 if (temp3)
17127 delete arg3;
17128 }
17129 return NULL;
17130 }
17131
17132
17133 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17134 PyObject *resultobj = 0;
17135 wxFileType *arg1 = (wxFileType *) 0 ;
17136 wxString *arg2 = 0 ;
17137 wxString const &arg3_defvalue = wxPyEmptyString ;
17138 wxString *arg3 = (wxString *) &arg3_defvalue ;
17139 PyObject *result = 0 ;
17140 void *argp1 = 0 ;
17141 int res1 = 0 ;
17142 bool temp2 = false ;
17143 bool temp3 = false ;
17144 PyObject * obj0 = 0 ;
17145 PyObject * obj1 = 0 ;
17146 PyObject * obj2 = 0 ;
17147 char * kwnames[] = {
17148 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17149 };
17150
17151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17153 if (!SWIG_IsOK(res1)) {
17154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17155 }
17156 arg1 = reinterpret_cast< wxFileType * >(argp1);
17157 {
17158 arg2 = wxString_in_helper(obj1);
17159 if (arg2 == NULL) SWIG_fail;
17160 temp2 = true;
17161 }
17162 if (obj2) {
17163 {
17164 arg3 = wxString_in_helper(obj2);
17165 if (arg3 == NULL) SWIG_fail;
17166 temp3 = true;
17167 }
17168 }
17169 {
17170 PyThreadState* __tstate = wxPyBeginAllowThreads();
17171 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17172 wxPyEndAllowThreads(__tstate);
17173 if (PyErr_Occurred()) SWIG_fail;
17174 }
17175 resultobj = result;
17176 {
17177 if (temp2)
17178 delete arg2;
17179 }
17180 {
17181 if (temp3)
17182 delete arg3;
17183 }
17184 return resultobj;
17185 fail:
17186 {
17187 if (temp2)
17188 delete arg2;
17189 }
17190 {
17191 if (temp3)
17192 delete arg3;
17193 }
17194 return NULL;
17195 }
17196
17197
17198 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17199 PyObject *resultobj = 0;
17200 wxFileType *arg1 = (wxFileType *) 0 ;
17201 wxString *arg2 = 0 ;
17202 wxString *arg3 = 0 ;
17203 bool arg4 = (bool) true ;
17204 bool result;
17205 void *argp1 = 0 ;
17206 int res1 = 0 ;
17207 bool temp2 = false ;
17208 bool temp3 = false ;
17209 bool val4 ;
17210 int ecode4 = 0 ;
17211 PyObject * obj0 = 0 ;
17212 PyObject * obj1 = 0 ;
17213 PyObject * obj2 = 0 ;
17214 PyObject * obj3 = 0 ;
17215 char * kwnames[] = {
17216 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17217 };
17218
17219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17221 if (!SWIG_IsOK(res1)) {
17222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17223 }
17224 arg1 = reinterpret_cast< wxFileType * >(argp1);
17225 {
17226 arg2 = wxString_in_helper(obj1);
17227 if (arg2 == NULL) SWIG_fail;
17228 temp2 = true;
17229 }
17230 {
17231 arg3 = wxString_in_helper(obj2);
17232 if (arg3 == NULL) SWIG_fail;
17233 temp3 = true;
17234 }
17235 if (obj3) {
17236 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17237 if (!SWIG_IsOK(ecode4)) {
17238 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17239 }
17240 arg4 = static_cast< bool >(val4);
17241 }
17242 {
17243 PyThreadState* __tstate = wxPyBeginAllowThreads();
17244 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17245 wxPyEndAllowThreads(__tstate);
17246 if (PyErr_Occurred()) SWIG_fail;
17247 }
17248 {
17249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17250 }
17251 {
17252 if (temp2)
17253 delete arg2;
17254 }
17255 {
17256 if (temp3)
17257 delete arg3;
17258 }
17259 return resultobj;
17260 fail:
17261 {
17262 if (temp2)
17263 delete arg2;
17264 }
17265 {
17266 if (temp3)
17267 delete arg3;
17268 }
17269 return NULL;
17270 }
17271
17272
17273 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17274 PyObject *resultobj = 0;
17275 wxFileType *arg1 = (wxFileType *) 0 ;
17276 wxString const &arg2_defvalue = wxPyEmptyString ;
17277 wxString *arg2 = (wxString *) &arg2_defvalue ;
17278 int arg3 = (int) 0 ;
17279 bool result;
17280 void *argp1 = 0 ;
17281 int res1 = 0 ;
17282 bool temp2 = false ;
17283 int val3 ;
17284 int ecode3 = 0 ;
17285 PyObject * obj0 = 0 ;
17286 PyObject * obj1 = 0 ;
17287 PyObject * obj2 = 0 ;
17288 char * kwnames[] = {
17289 (char *) "self",(char *) "cmd",(char *) "index", NULL
17290 };
17291
17292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17294 if (!SWIG_IsOK(res1)) {
17295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17296 }
17297 arg1 = reinterpret_cast< wxFileType * >(argp1);
17298 if (obj1) {
17299 {
17300 arg2 = wxString_in_helper(obj1);
17301 if (arg2 == NULL) SWIG_fail;
17302 temp2 = true;
17303 }
17304 }
17305 if (obj2) {
17306 ecode3 = SWIG_AsVal_int(obj2, &val3);
17307 if (!SWIG_IsOK(ecode3)) {
17308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17309 }
17310 arg3 = static_cast< int >(val3);
17311 }
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 {
17319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17320 }
17321 {
17322 if (temp2)
17323 delete arg2;
17324 }
17325 return resultobj;
17326 fail:
17327 {
17328 if (temp2)
17329 delete arg2;
17330 }
17331 return NULL;
17332 }
17333
17334
17335 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17336 PyObject *resultobj = 0;
17337 wxFileType *arg1 = (wxFileType *) 0 ;
17338 bool result;
17339 void *argp1 = 0 ;
17340 int res1 = 0 ;
17341 PyObject *swig_obj[1] ;
17342
17343 if (!args) SWIG_fail;
17344 swig_obj[0] = args;
17345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17346 if (!SWIG_IsOK(res1)) {
17347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17348 }
17349 arg1 = reinterpret_cast< wxFileType * >(argp1);
17350 {
17351 PyThreadState* __tstate = wxPyBeginAllowThreads();
17352 result = (bool)(arg1)->Unassociate();
17353 wxPyEndAllowThreads(__tstate);
17354 if (PyErr_Occurred()) SWIG_fail;
17355 }
17356 {
17357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17358 }
17359 return resultobj;
17360 fail:
17361 return NULL;
17362 }
17363
17364
17365 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17366 PyObject *resultobj = 0;
17367 wxString *arg1 = 0 ;
17368 wxString *arg2 = 0 ;
17369 wxString const &arg3_defvalue = wxPyEmptyString ;
17370 wxString *arg3 = (wxString *) &arg3_defvalue ;
17371 wxString result;
17372 bool temp1 = false ;
17373 bool temp2 = false ;
17374 bool temp3 = false ;
17375 PyObject * obj0 = 0 ;
17376 PyObject * obj1 = 0 ;
17377 PyObject * obj2 = 0 ;
17378 char * kwnames[] = {
17379 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17380 };
17381
17382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17383 {
17384 arg1 = wxString_in_helper(obj0);
17385 if (arg1 == NULL) SWIG_fail;
17386 temp1 = true;
17387 }
17388 {
17389 arg2 = wxString_in_helper(obj1);
17390 if (arg2 == NULL) SWIG_fail;
17391 temp2 = true;
17392 }
17393 if (obj2) {
17394 {
17395 arg3 = wxString_in_helper(obj2);
17396 if (arg3 == NULL) SWIG_fail;
17397 temp3 = true;
17398 }
17399 }
17400 {
17401 PyThreadState* __tstate = wxPyBeginAllowThreads();
17402 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17403 wxPyEndAllowThreads(__tstate);
17404 if (PyErr_Occurred()) SWIG_fail;
17405 }
17406 {
17407 #if wxUSE_UNICODE
17408 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17409 #else
17410 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17411 #endif
17412 }
17413 {
17414 if (temp1)
17415 delete arg1;
17416 }
17417 {
17418 if (temp2)
17419 delete arg2;
17420 }
17421 {
17422 if (temp3)
17423 delete arg3;
17424 }
17425 return resultobj;
17426 fail:
17427 {
17428 if (temp1)
17429 delete arg1;
17430 }
17431 {
17432 if (temp2)
17433 delete arg2;
17434 }
17435 {
17436 if (temp3)
17437 delete arg3;
17438 }
17439 return NULL;
17440 }
17441
17442
17443 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17444 PyObject *obj;
17445 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17446 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17447 return SWIG_Py_Void();
17448 }
17449
17450 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17451 return SWIG_Python_InitShadowInstance(args);
17452 }
17453
17454 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17455 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17456 return 1;
17457 }
17458
17459
17460 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17461 PyObject *pyobj = 0;
17462
17463 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17464 return pyobj;
17465 }
17466
17467
17468 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17469 PyObject *resultobj = 0;
17470 wxString *arg1 = 0 ;
17471 wxString *arg2 = 0 ;
17472 bool result;
17473 bool temp1 = false ;
17474 bool temp2 = false ;
17475 PyObject * obj0 = 0 ;
17476 PyObject * obj1 = 0 ;
17477 char * kwnames[] = {
17478 (char *) "mimeType",(char *) "wildcard", NULL
17479 };
17480
17481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17482 {
17483 arg1 = wxString_in_helper(obj0);
17484 if (arg1 == NULL) SWIG_fail;
17485 temp1 = true;
17486 }
17487 {
17488 arg2 = wxString_in_helper(obj1);
17489 if (arg2 == NULL) SWIG_fail;
17490 temp2 = true;
17491 }
17492 {
17493 PyThreadState* __tstate = wxPyBeginAllowThreads();
17494 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17495 wxPyEndAllowThreads(__tstate);
17496 if (PyErr_Occurred()) SWIG_fail;
17497 }
17498 {
17499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17500 }
17501 {
17502 if (temp1)
17503 delete arg1;
17504 }
17505 {
17506 if (temp2)
17507 delete arg2;
17508 }
17509 return resultobj;
17510 fail:
17511 {
17512 if (temp1)
17513 delete arg1;
17514 }
17515 {
17516 if (temp2)
17517 delete arg2;
17518 }
17519 return NULL;
17520 }
17521
17522
17523 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17524 PyObject *resultobj = 0;
17525 wxMimeTypesManager *result = 0 ;
17526
17527 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17528 {
17529 PyThreadState* __tstate = wxPyBeginAllowThreads();
17530 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17531 wxPyEndAllowThreads(__tstate);
17532 if (PyErr_Occurred()) SWIG_fail;
17533 }
17534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj = 0;
17543 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17544 int arg2 = (int) wxMAILCAP_ALL ;
17545 wxString const &arg3_defvalue = wxPyEmptyString ;
17546 wxString *arg3 = (wxString *) &arg3_defvalue ;
17547 void *argp1 = 0 ;
17548 int res1 = 0 ;
17549 int val2 ;
17550 int ecode2 = 0 ;
17551 bool temp3 = false ;
17552 PyObject * obj0 = 0 ;
17553 PyObject * obj1 = 0 ;
17554 PyObject * obj2 = 0 ;
17555 char * kwnames[] = {
17556 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17557 };
17558
17559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17561 if (!SWIG_IsOK(res1)) {
17562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17563 }
17564 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17565 if (obj1) {
17566 ecode2 = SWIG_AsVal_int(obj1, &val2);
17567 if (!SWIG_IsOK(ecode2)) {
17568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17569 }
17570 arg2 = static_cast< int >(val2);
17571 }
17572 if (obj2) {
17573 {
17574 arg3 = wxString_in_helper(obj2);
17575 if (arg3 == NULL) SWIG_fail;
17576 temp3 = true;
17577 }
17578 }
17579 {
17580 PyThreadState* __tstate = wxPyBeginAllowThreads();
17581 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17582 wxPyEndAllowThreads(__tstate);
17583 if (PyErr_Occurred()) SWIG_fail;
17584 }
17585 resultobj = SWIG_Py_Void();
17586 {
17587 if (temp3)
17588 delete arg3;
17589 }
17590 return resultobj;
17591 fail:
17592 {
17593 if (temp3)
17594 delete arg3;
17595 }
17596 return NULL;
17597 }
17598
17599
17600 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17601 PyObject *resultobj = 0;
17602 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17603 void *argp1 = 0 ;
17604 int res1 = 0 ;
17605 PyObject *swig_obj[1] ;
17606
17607 if (!args) SWIG_fail;
17608 swig_obj[0] = args;
17609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17610 if (!SWIG_IsOK(res1)) {
17611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17612 }
17613 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17614 {
17615 PyThreadState* __tstate = wxPyBeginAllowThreads();
17616 (arg1)->ClearData();
17617 wxPyEndAllowThreads(__tstate);
17618 if (PyErr_Occurred()) SWIG_fail;
17619 }
17620 resultobj = SWIG_Py_Void();
17621 return resultobj;
17622 fail:
17623 return NULL;
17624 }
17625
17626
17627 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17628 PyObject *resultobj = 0;
17629 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17630 wxString *arg2 = 0 ;
17631 wxFileType *result = 0 ;
17632 void *argp1 = 0 ;
17633 int res1 = 0 ;
17634 bool temp2 = false ;
17635 PyObject * obj0 = 0 ;
17636 PyObject * obj1 = 0 ;
17637 char * kwnames[] = {
17638 (char *) "self",(char *) "ext", NULL
17639 };
17640
17641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17643 if (!SWIG_IsOK(res1)) {
17644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17645 }
17646 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17647 {
17648 arg2 = wxString_in_helper(obj1);
17649 if (arg2 == NULL) SWIG_fail;
17650 temp2 = true;
17651 }
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17655 wxPyEndAllowThreads(__tstate);
17656 if (PyErr_Occurred()) SWIG_fail;
17657 }
17658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17659 {
17660 if (temp2)
17661 delete arg2;
17662 }
17663 return resultobj;
17664 fail:
17665 {
17666 if (temp2)
17667 delete arg2;
17668 }
17669 return NULL;
17670 }
17671
17672
17673 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17674 PyObject *resultobj = 0;
17675 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17676 wxString *arg2 = 0 ;
17677 wxFileType *result = 0 ;
17678 void *argp1 = 0 ;
17679 int res1 = 0 ;
17680 bool temp2 = false ;
17681 PyObject * obj0 = 0 ;
17682 PyObject * obj1 = 0 ;
17683 char * kwnames[] = {
17684 (char *) "self",(char *) "mimeType", NULL
17685 };
17686
17687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17689 if (!SWIG_IsOK(res1)) {
17690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17691 }
17692 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17693 {
17694 arg2 = wxString_in_helper(obj1);
17695 if (arg2 == NULL) SWIG_fail;
17696 temp2 = true;
17697 }
17698 {
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17701 wxPyEndAllowThreads(__tstate);
17702 if (PyErr_Occurred()) SWIG_fail;
17703 }
17704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17705 {
17706 if (temp2)
17707 delete arg2;
17708 }
17709 return resultobj;
17710 fail:
17711 {
17712 if (temp2)
17713 delete arg2;
17714 }
17715 return NULL;
17716 }
17717
17718
17719 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17720 PyObject *resultobj = 0;
17721 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17722 wxString *arg2 = 0 ;
17723 bool arg3 = (bool) false ;
17724 bool result;
17725 void *argp1 = 0 ;
17726 int res1 = 0 ;
17727 bool temp2 = false ;
17728 bool val3 ;
17729 int ecode3 = 0 ;
17730 PyObject * obj0 = 0 ;
17731 PyObject * obj1 = 0 ;
17732 PyObject * obj2 = 0 ;
17733 char * kwnames[] = {
17734 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17735 };
17736
17737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17739 if (!SWIG_IsOK(res1)) {
17740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17741 }
17742 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17743 {
17744 arg2 = wxString_in_helper(obj1);
17745 if (arg2 == NULL) SWIG_fail;
17746 temp2 = true;
17747 }
17748 if (obj2) {
17749 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17750 if (!SWIG_IsOK(ecode3)) {
17751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17752 }
17753 arg3 = static_cast< bool >(val3);
17754 }
17755 {
17756 PyThreadState* __tstate = wxPyBeginAllowThreads();
17757 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17758 wxPyEndAllowThreads(__tstate);
17759 if (PyErr_Occurred()) SWIG_fail;
17760 }
17761 {
17762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17763 }
17764 {
17765 if (temp2)
17766 delete arg2;
17767 }
17768 return resultobj;
17769 fail:
17770 {
17771 if (temp2)
17772 delete arg2;
17773 }
17774 return NULL;
17775 }
17776
17777
17778 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17779 PyObject *resultobj = 0;
17780 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17781 wxString *arg2 = 0 ;
17782 bool result;
17783 void *argp1 = 0 ;
17784 int res1 = 0 ;
17785 bool temp2 = false ;
17786 PyObject * obj0 = 0 ;
17787 PyObject * obj1 = 0 ;
17788 char * kwnames[] = {
17789 (char *) "self",(char *) "filename", NULL
17790 };
17791
17792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17794 if (!SWIG_IsOK(res1)) {
17795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17796 }
17797 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17798 {
17799 arg2 = wxString_in_helper(obj1);
17800 if (arg2 == NULL) SWIG_fail;
17801 temp2 = true;
17802 }
17803 {
17804 PyThreadState* __tstate = wxPyBeginAllowThreads();
17805 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17806 wxPyEndAllowThreads(__tstate);
17807 if (PyErr_Occurred()) SWIG_fail;
17808 }
17809 {
17810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17811 }
17812 {
17813 if (temp2)
17814 delete arg2;
17815 }
17816 return resultobj;
17817 fail:
17818 {
17819 if (temp2)
17820 delete arg2;
17821 }
17822 return NULL;
17823 }
17824
17825
17826 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17827 PyObject *resultobj = 0;
17828 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17829 PyObject *result = 0 ;
17830 void *argp1 = 0 ;
17831 int res1 = 0 ;
17832 PyObject *swig_obj[1] ;
17833
17834 if (!args) SWIG_fail;
17835 swig_obj[0] = args;
17836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17837 if (!SWIG_IsOK(res1)) {
17838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17839 }
17840 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17841 {
17842 PyThreadState* __tstate = wxPyBeginAllowThreads();
17843 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17844 wxPyEndAllowThreads(__tstate);
17845 if (PyErr_Occurred()) SWIG_fail;
17846 }
17847 resultobj = result;
17848 return resultobj;
17849 fail:
17850 return NULL;
17851 }
17852
17853
17854 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17855 PyObject *resultobj = 0;
17856 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17857 wxFileTypeInfo *arg2 = 0 ;
17858 void *argp1 = 0 ;
17859 int res1 = 0 ;
17860 void *argp2 = 0 ;
17861 int res2 = 0 ;
17862 PyObject * obj0 = 0 ;
17863 PyObject * obj1 = 0 ;
17864 char * kwnames[] = {
17865 (char *) "self",(char *) "ft", NULL
17866 };
17867
17868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17870 if (!SWIG_IsOK(res1)) {
17871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17872 }
17873 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17874 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17875 if (!SWIG_IsOK(res2)) {
17876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17877 }
17878 if (!argp2) {
17879 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17880 }
17881 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 resultobj = SWIG_Py_Void();
17889 return resultobj;
17890 fail:
17891 return NULL;
17892 }
17893
17894
17895 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17896 PyObject *resultobj = 0;
17897 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17898 wxFileTypeInfo *arg2 = 0 ;
17899 wxFileType *result = 0 ;
17900 void *argp1 = 0 ;
17901 int res1 = 0 ;
17902 void *argp2 = 0 ;
17903 int res2 = 0 ;
17904 PyObject * obj0 = 0 ;
17905 PyObject * obj1 = 0 ;
17906 char * kwnames[] = {
17907 (char *) "self",(char *) "ftInfo", NULL
17908 };
17909
17910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17912 if (!SWIG_IsOK(res1)) {
17913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17914 }
17915 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17916 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17917 if (!SWIG_IsOK(res2)) {
17918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17919 }
17920 if (!argp2) {
17921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17922 }
17923 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17924 {
17925 PyThreadState* __tstate = wxPyBeginAllowThreads();
17926 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17927 wxPyEndAllowThreads(__tstate);
17928 if (PyErr_Occurred()) SWIG_fail;
17929 }
17930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17931 return resultobj;
17932 fail:
17933 return NULL;
17934 }
17935
17936
17937 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17938 PyObject *resultobj = 0;
17939 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17940 wxFileType *arg2 = (wxFileType *) 0 ;
17941 bool result;
17942 void *argp1 = 0 ;
17943 int res1 = 0 ;
17944 void *argp2 = 0 ;
17945 int res2 = 0 ;
17946 PyObject * obj0 = 0 ;
17947 PyObject * obj1 = 0 ;
17948 char * kwnames[] = {
17949 (char *) "self",(char *) "ft", NULL
17950 };
17951
17952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17954 if (!SWIG_IsOK(res1)) {
17955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17956 }
17957 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17958 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17959 if (!SWIG_IsOK(res2)) {
17960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17961 }
17962 arg2 = reinterpret_cast< wxFileType * >(argp2);
17963 {
17964 PyThreadState* __tstate = wxPyBeginAllowThreads();
17965 result = (bool)(arg1)->Unassociate(arg2);
17966 wxPyEndAllowThreads(__tstate);
17967 if (PyErr_Occurred()) SWIG_fail;
17968 }
17969 {
17970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17971 }
17972 return resultobj;
17973 fail:
17974 return NULL;
17975 }
17976
17977
17978 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17979 PyObject *resultobj = 0;
17980 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17981 void *argp1 = 0 ;
17982 int res1 = 0 ;
17983 PyObject *swig_obj[1] ;
17984
17985 if (!args) SWIG_fail;
17986 swig_obj[0] = args;
17987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17988 if (!SWIG_IsOK(res1)) {
17989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17990 }
17991 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17992 {
17993 PyThreadState* __tstate = wxPyBeginAllowThreads();
17994 delete arg1;
17995
17996 wxPyEndAllowThreads(__tstate);
17997 if (PyErr_Occurred()) SWIG_fail;
17998 }
17999 resultobj = SWIG_Py_Void();
18000 return resultobj;
18001 fail:
18002 return NULL;
18003 }
18004
18005
18006 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18007 PyObject *obj;
18008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18009 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18010 return SWIG_Py_Void();
18011 }
18012
18013 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18014 return SWIG_Python_InitShadowInstance(args);
18015 }
18016
18017 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18018 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18019 return 1;
18020 }
18021
18022
18023 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18024 PyObject *pyobj = 0;
18025
18026 {
18027 #if wxUSE_UNICODE
18028 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18029 #else
18030 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18031 #endif
18032 }
18033 return pyobj;
18034 }
18035
18036
18037 SWIGINTERN int ART_MENU_set(PyObject *) {
18038 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18039 return 1;
18040 }
18041
18042
18043 SWIGINTERN PyObject *ART_MENU_get(void) {
18044 PyObject *pyobj = 0;
18045
18046 {
18047 #if wxUSE_UNICODE
18048 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18049 #else
18050 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18051 #endif
18052 }
18053 return pyobj;
18054 }
18055
18056
18057 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18058 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18059 return 1;
18060 }
18061
18062
18063 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18064 PyObject *pyobj = 0;
18065
18066 {
18067 #if wxUSE_UNICODE
18068 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18069 #else
18070 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18071 #endif
18072 }
18073 return pyobj;
18074 }
18075
18076
18077 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18078 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18079 return 1;
18080 }
18081
18082
18083 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18084 PyObject *pyobj = 0;
18085
18086 {
18087 #if wxUSE_UNICODE
18088 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18089 #else
18090 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18091 #endif
18092 }
18093 return pyobj;
18094 }
18095
18096
18097 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18098 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18099 return 1;
18100 }
18101
18102
18103 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18104 PyObject *pyobj = 0;
18105
18106 {
18107 #if wxUSE_UNICODE
18108 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18109 #else
18110 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18111 #endif
18112 }
18113 return pyobj;
18114 }
18115
18116
18117 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18118 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18119 return 1;
18120 }
18121
18122
18123 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18124 PyObject *pyobj = 0;
18125
18126 {
18127 #if wxUSE_UNICODE
18128 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18129 #else
18130 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18131 #endif
18132 }
18133 return pyobj;
18134 }
18135
18136
18137 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18138 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18139 return 1;
18140 }
18141
18142
18143 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18144 PyObject *pyobj = 0;
18145
18146 {
18147 #if wxUSE_UNICODE
18148 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18149 #else
18150 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18151 #endif
18152 }
18153 return pyobj;
18154 }
18155
18156
18157 SWIGINTERN int ART_OTHER_set(PyObject *) {
18158 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18159 return 1;
18160 }
18161
18162
18163 SWIGINTERN PyObject *ART_OTHER_get(void) {
18164 PyObject *pyobj = 0;
18165
18166 {
18167 #if wxUSE_UNICODE
18168 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18169 #else
18170 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18171 #endif
18172 }
18173 return pyobj;
18174 }
18175
18176
18177 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18178 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18179 return 1;
18180 }
18181
18182
18183 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18184 PyObject *pyobj = 0;
18185
18186 {
18187 #if wxUSE_UNICODE
18188 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18189 #else
18190 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18191 #endif
18192 }
18193 return pyobj;
18194 }
18195
18196
18197 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18198 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18199 return 1;
18200 }
18201
18202
18203 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18204 PyObject *pyobj = 0;
18205
18206 {
18207 #if wxUSE_UNICODE
18208 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18209 #else
18210 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18211 #endif
18212 }
18213 return pyobj;
18214 }
18215
18216
18217 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18218 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18219 return 1;
18220 }
18221
18222
18223 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18224 PyObject *pyobj = 0;
18225
18226 {
18227 #if wxUSE_UNICODE
18228 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18229 #else
18230 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18231 #endif
18232 }
18233 return pyobj;
18234 }
18235
18236
18237 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18238 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18239 return 1;
18240 }
18241
18242
18243 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18244 PyObject *pyobj = 0;
18245
18246 {
18247 #if wxUSE_UNICODE
18248 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18249 #else
18250 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18251 #endif
18252 }
18253 return pyobj;
18254 }
18255
18256
18257 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18258 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18259 return 1;
18260 }
18261
18262
18263 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18264 PyObject *pyobj = 0;
18265
18266 {
18267 #if wxUSE_UNICODE
18268 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18269 #else
18270 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18271 #endif
18272 }
18273 return pyobj;
18274 }
18275
18276
18277 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18278 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18279 return 1;
18280 }
18281
18282
18283 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18284 PyObject *pyobj = 0;
18285
18286 {
18287 #if wxUSE_UNICODE
18288 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18289 #else
18290 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18291 #endif
18292 }
18293 return pyobj;
18294 }
18295
18296
18297 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18298 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18299 return 1;
18300 }
18301
18302
18303 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18304 PyObject *pyobj = 0;
18305
18306 {
18307 #if wxUSE_UNICODE
18308 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18309 #else
18310 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18311 #endif
18312 }
18313 return pyobj;
18314 }
18315
18316
18317 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18318 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18319 return 1;
18320 }
18321
18322
18323 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18324 PyObject *pyobj = 0;
18325
18326 {
18327 #if wxUSE_UNICODE
18328 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18329 #else
18330 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18331 #endif
18332 }
18333 return pyobj;
18334 }
18335
18336
18337 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18338 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18339 return 1;
18340 }
18341
18342
18343 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18344 PyObject *pyobj = 0;
18345
18346 {
18347 #if wxUSE_UNICODE
18348 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18349 #else
18350 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18351 #endif
18352 }
18353 return pyobj;
18354 }
18355
18356
18357 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18358 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18359 return 1;
18360 }
18361
18362
18363 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18364 PyObject *pyobj = 0;
18365
18366 {
18367 #if wxUSE_UNICODE
18368 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18369 #else
18370 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18371 #endif
18372 }
18373 return pyobj;
18374 }
18375
18376
18377 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18378 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18379 return 1;
18380 }
18381
18382
18383 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18384 PyObject *pyobj = 0;
18385
18386 {
18387 #if wxUSE_UNICODE
18388 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18389 #else
18390 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18391 #endif
18392 }
18393 return pyobj;
18394 }
18395
18396
18397 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18398 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18399 return 1;
18400 }
18401
18402
18403 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18404 PyObject *pyobj = 0;
18405
18406 {
18407 #if wxUSE_UNICODE
18408 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18409 #else
18410 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18411 #endif
18412 }
18413 return pyobj;
18414 }
18415
18416
18417 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18418 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18419 return 1;
18420 }
18421
18422
18423 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18424 PyObject *pyobj = 0;
18425
18426 {
18427 #if wxUSE_UNICODE
18428 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18429 #else
18430 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18431 #endif
18432 }
18433 return pyobj;
18434 }
18435
18436
18437 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18438 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18439 return 1;
18440 }
18441
18442
18443 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18444 PyObject *pyobj = 0;
18445
18446 {
18447 #if wxUSE_UNICODE
18448 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18449 #else
18450 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18451 #endif
18452 }
18453 return pyobj;
18454 }
18455
18456
18457 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18458 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18459 return 1;
18460 }
18461
18462
18463 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18464 PyObject *pyobj = 0;
18465
18466 {
18467 #if wxUSE_UNICODE
18468 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18469 #else
18470 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18471 #endif
18472 }
18473 return pyobj;
18474 }
18475
18476
18477 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18478 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18479 return 1;
18480 }
18481
18482
18483 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18484 PyObject *pyobj = 0;
18485
18486 {
18487 #if wxUSE_UNICODE
18488 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18489 #else
18490 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18491 #endif
18492 }
18493 return pyobj;
18494 }
18495
18496
18497 SWIGINTERN int ART_PRINT_set(PyObject *) {
18498 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18499 return 1;
18500 }
18501
18502
18503 SWIGINTERN PyObject *ART_PRINT_get(void) {
18504 PyObject *pyobj = 0;
18505
18506 {
18507 #if wxUSE_UNICODE
18508 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18509 #else
18510 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18511 #endif
18512 }
18513 return pyobj;
18514 }
18515
18516
18517 SWIGINTERN int ART_HELP_set(PyObject *) {
18518 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18519 return 1;
18520 }
18521
18522
18523 SWIGINTERN PyObject *ART_HELP_get(void) {
18524 PyObject *pyobj = 0;
18525
18526 {
18527 #if wxUSE_UNICODE
18528 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18529 #else
18530 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18531 #endif
18532 }
18533 return pyobj;
18534 }
18535
18536
18537 SWIGINTERN int ART_TIP_set(PyObject *) {
18538 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18539 return 1;
18540 }
18541
18542
18543 SWIGINTERN PyObject *ART_TIP_get(void) {
18544 PyObject *pyobj = 0;
18545
18546 {
18547 #if wxUSE_UNICODE
18548 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18549 #else
18550 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18551 #endif
18552 }
18553 return pyobj;
18554 }
18555
18556
18557 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18558 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18559 return 1;
18560 }
18561
18562
18563 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18564 PyObject *pyobj = 0;
18565
18566 {
18567 #if wxUSE_UNICODE
18568 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18569 #else
18570 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18571 #endif
18572 }
18573 return pyobj;
18574 }
18575
18576
18577 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18578 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18579 return 1;
18580 }
18581
18582
18583 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18584 PyObject *pyobj = 0;
18585
18586 {
18587 #if wxUSE_UNICODE
18588 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18589 #else
18590 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18591 #endif
18592 }
18593 return pyobj;
18594 }
18595
18596
18597 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18598 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18599 return 1;
18600 }
18601
18602
18603 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18604 PyObject *pyobj = 0;
18605
18606 {
18607 #if wxUSE_UNICODE
18608 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18609 #else
18610 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18611 #endif
18612 }
18613 return pyobj;
18614 }
18615
18616
18617 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18618 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18619 return 1;
18620 }
18621
18622
18623 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18624 PyObject *pyobj = 0;
18625
18626 {
18627 #if wxUSE_UNICODE
18628 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18629 #else
18630 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18631 #endif
18632 }
18633 return pyobj;
18634 }
18635
18636
18637 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18638 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18639 return 1;
18640 }
18641
18642
18643 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18644 PyObject *pyobj = 0;
18645
18646 {
18647 #if wxUSE_UNICODE
18648 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18649 #else
18650 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18651 #endif
18652 }
18653 return pyobj;
18654 }
18655
18656
18657 SWIGINTERN int ART_CDROM_set(PyObject *) {
18658 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18659 return 1;
18660 }
18661
18662
18663 SWIGINTERN PyObject *ART_CDROM_get(void) {
18664 PyObject *pyobj = 0;
18665
18666 {
18667 #if wxUSE_UNICODE
18668 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18669 #else
18670 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18671 #endif
18672 }
18673 return pyobj;
18674 }
18675
18676
18677 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18678 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18679 return 1;
18680 }
18681
18682
18683 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18684 PyObject *pyobj = 0;
18685
18686 {
18687 #if wxUSE_UNICODE
18688 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18689 #else
18690 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18691 #endif
18692 }
18693 return pyobj;
18694 }
18695
18696
18697 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18698 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18699 return 1;
18700 }
18701
18702
18703 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18704 PyObject *pyobj = 0;
18705
18706 {
18707 #if wxUSE_UNICODE
18708 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18709 #else
18710 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18711 #endif
18712 }
18713 return pyobj;
18714 }
18715
18716
18717 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18718 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18719 return 1;
18720 }
18721
18722
18723 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18724 PyObject *pyobj = 0;
18725
18726 {
18727 #if wxUSE_UNICODE
18728 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18729 #else
18730 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18731 #endif
18732 }
18733 return pyobj;
18734 }
18735
18736
18737 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18738 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18739 return 1;
18740 }
18741
18742
18743 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18744 PyObject *pyobj = 0;
18745
18746 {
18747 #if wxUSE_UNICODE
18748 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18749 #else
18750 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18751 #endif
18752 }
18753 return pyobj;
18754 }
18755
18756
18757 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18758 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18759 return 1;
18760 }
18761
18762
18763 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18764 PyObject *pyobj = 0;
18765
18766 {
18767 #if wxUSE_UNICODE
18768 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18769 #else
18770 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18771 #endif
18772 }
18773 return pyobj;
18774 }
18775
18776
18777 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18778 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18779 return 1;
18780 }
18781
18782
18783 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18784 PyObject *pyobj = 0;
18785
18786 {
18787 #if wxUSE_UNICODE
18788 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18789 #else
18790 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18791 #endif
18792 }
18793 return pyobj;
18794 }
18795
18796
18797 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18798 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18799 return 1;
18800 }
18801
18802
18803 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18804 PyObject *pyobj = 0;
18805
18806 {
18807 #if wxUSE_UNICODE
18808 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18809 #else
18810 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18811 #endif
18812 }
18813 return pyobj;
18814 }
18815
18816
18817 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18818 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18819 return 1;
18820 }
18821
18822
18823 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18824 PyObject *pyobj = 0;
18825
18826 {
18827 #if wxUSE_UNICODE
18828 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18829 #else
18830 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18831 #endif
18832 }
18833 return pyobj;
18834 }
18835
18836
18837 SWIGINTERN int ART_ERROR_set(PyObject *) {
18838 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18839 return 1;
18840 }
18841
18842
18843 SWIGINTERN PyObject *ART_ERROR_get(void) {
18844 PyObject *pyobj = 0;
18845
18846 {
18847 #if wxUSE_UNICODE
18848 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18849 #else
18850 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18851 #endif
18852 }
18853 return pyobj;
18854 }
18855
18856
18857 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18858 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18859 return 1;
18860 }
18861
18862
18863 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18864 PyObject *pyobj = 0;
18865
18866 {
18867 #if wxUSE_UNICODE
18868 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18869 #else
18870 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18871 #endif
18872 }
18873 return pyobj;
18874 }
18875
18876
18877 SWIGINTERN int ART_WARNING_set(PyObject *) {
18878 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18879 return 1;
18880 }
18881
18882
18883 SWIGINTERN PyObject *ART_WARNING_get(void) {
18884 PyObject *pyobj = 0;
18885
18886 {
18887 #if wxUSE_UNICODE
18888 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18889 #else
18890 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18891 #endif
18892 }
18893 return pyobj;
18894 }
18895
18896
18897 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18898 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18899 return 1;
18900 }
18901
18902
18903 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18904 PyObject *pyobj = 0;
18905
18906 {
18907 #if wxUSE_UNICODE
18908 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18909 #else
18910 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18911 #endif
18912 }
18913 return pyobj;
18914 }
18915
18916
18917 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18918 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18919 return 1;
18920 }
18921
18922
18923 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18924 PyObject *pyobj = 0;
18925
18926 {
18927 #if wxUSE_UNICODE
18928 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18929 #else
18930 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18931 #endif
18932 }
18933 return pyobj;
18934 }
18935
18936
18937 SWIGINTERN int ART_COPY_set(PyObject *) {
18938 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18939 return 1;
18940 }
18941
18942
18943 SWIGINTERN PyObject *ART_COPY_get(void) {
18944 PyObject *pyobj = 0;
18945
18946 {
18947 #if wxUSE_UNICODE
18948 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18949 #else
18950 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18951 #endif
18952 }
18953 return pyobj;
18954 }
18955
18956
18957 SWIGINTERN int ART_CUT_set(PyObject *) {
18958 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18959 return 1;
18960 }
18961
18962
18963 SWIGINTERN PyObject *ART_CUT_get(void) {
18964 PyObject *pyobj = 0;
18965
18966 {
18967 #if wxUSE_UNICODE
18968 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18969 #else
18970 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18971 #endif
18972 }
18973 return pyobj;
18974 }
18975
18976
18977 SWIGINTERN int ART_PASTE_set(PyObject *) {
18978 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18979 return 1;
18980 }
18981
18982
18983 SWIGINTERN PyObject *ART_PASTE_get(void) {
18984 PyObject *pyobj = 0;
18985
18986 {
18987 #if wxUSE_UNICODE
18988 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18989 #else
18990 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18991 #endif
18992 }
18993 return pyobj;
18994 }
18995
18996
18997 SWIGINTERN int ART_DELETE_set(PyObject *) {
18998 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
18999 return 1;
19000 }
19001
19002
19003 SWIGINTERN PyObject *ART_DELETE_get(void) {
19004 PyObject *pyobj = 0;
19005
19006 {
19007 #if wxUSE_UNICODE
19008 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19009 #else
19010 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19011 #endif
19012 }
19013 return pyobj;
19014 }
19015
19016
19017 SWIGINTERN int ART_NEW_set(PyObject *) {
19018 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19019 return 1;
19020 }
19021
19022
19023 SWIGINTERN PyObject *ART_NEW_get(void) {
19024 PyObject *pyobj = 0;
19025
19026 {
19027 #if wxUSE_UNICODE
19028 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19029 #else
19030 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19031 #endif
19032 }
19033 return pyobj;
19034 }
19035
19036
19037 SWIGINTERN int ART_UNDO_set(PyObject *) {
19038 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19039 return 1;
19040 }
19041
19042
19043 SWIGINTERN PyObject *ART_UNDO_get(void) {
19044 PyObject *pyobj = 0;
19045
19046 {
19047 #if wxUSE_UNICODE
19048 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19049 #else
19050 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19051 #endif
19052 }
19053 return pyobj;
19054 }
19055
19056
19057 SWIGINTERN int ART_REDO_set(PyObject *) {
19058 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19059 return 1;
19060 }
19061
19062
19063 SWIGINTERN PyObject *ART_REDO_get(void) {
19064 PyObject *pyobj = 0;
19065
19066 {
19067 #if wxUSE_UNICODE
19068 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19069 #else
19070 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19071 #endif
19072 }
19073 return pyobj;
19074 }
19075
19076
19077 SWIGINTERN int ART_QUIT_set(PyObject *) {
19078 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19079 return 1;
19080 }
19081
19082
19083 SWIGINTERN PyObject *ART_QUIT_get(void) {
19084 PyObject *pyobj = 0;
19085
19086 {
19087 #if wxUSE_UNICODE
19088 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19089 #else
19090 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19091 #endif
19092 }
19093 return pyobj;
19094 }
19095
19096
19097 SWIGINTERN int ART_FIND_set(PyObject *) {
19098 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19099 return 1;
19100 }
19101
19102
19103 SWIGINTERN PyObject *ART_FIND_get(void) {
19104 PyObject *pyobj = 0;
19105
19106 {
19107 #if wxUSE_UNICODE
19108 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19109 #else
19110 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19111 #endif
19112 }
19113 return pyobj;
19114 }
19115
19116
19117 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19118 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19119 return 1;
19120 }
19121
19122
19123 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19124 PyObject *pyobj = 0;
19125
19126 {
19127 #if wxUSE_UNICODE
19128 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19129 #else
19130 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19131 #endif
19132 }
19133 return pyobj;
19134 }
19135
19136
19137 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19138 PyObject *resultobj = 0;
19139 wxPyArtProvider *result = 0 ;
19140
19141 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19142 {
19143 if (!wxPyCheckForApp()) SWIG_fail;
19144 PyThreadState* __tstate = wxPyBeginAllowThreads();
19145 result = (wxPyArtProvider *)new wxPyArtProvider();
19146 wxPyEndAllowThreads(__tstate);
19147 if (PyErr_Occurred()) SWIG_fail;
19148 }
19149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19150 return resultobj;
19151 fail:
19152 return NULL;
19153 }
19154
19155
19156 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19157 PyObject *resultobj = 0;
19158 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19159 void *argp1 = 0 ;
19160 int res1 = 0 ;
19161 PyObject *swig_obj[1] ;
19162
19163 if (!args) SWIG_fail;
19164 swig_obj[0] = args;
19165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19166 if (!SWIG_IsOK(res1)) {
19167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19168 }
19169 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19170 {
19171 PyThreadState* __tstate = wxPyBeginAllowThreads();
19172 delete arg1;
19173
19174 wxPyEndAllowThreads(__tstate);
19175 if (PyErr_Occurred()) SWIG_fail;
19176 }
19177 resultobj = SWIG_Py_Void();
19178 return resultobj;
19179 fail:
19180 return NULL;
19181 }
19182
19183
19184 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19185 PyObject *resultobj = 0;
19186 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19187 PyObject *arg2 = (PyObject *) 0 ;
19188 PyObject *arg3 = (PyObject *) 0 ;
19189 void *argp1 = 0 ;
19190 int res1 = 0 ;
19191 PyObject * obj0 = 0 ;
19192 PyObject * obj1 = 0 ;
19193 PyObject * obj2 = 0 ;
19194 char * kwnames[] = {
19195 (char *) "self",(char *) "self",(char *) "_class", NULL
19196 };
19197
19198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19200 if (!SWIG_IsOK(res1)) {
19201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19202 }
19203 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19204 arg2 = obj1;
19205 arg3 = obj2;
19206 {
19207 PyThreadState* __tstate = wxPyBeginAllowThreads();
19208 (arg1)->_setCallbackInfo(arg2,arg3);
19209 wxPyEndAllowThreads(__tstate);
19210 if (PyErr_Occurred()) SWIG_fail;
19211 }
19212 resultobj = SWIG_Py_Void();
19213 return resultobj;
19214 fail:
19215 return NULL;
19216 }
19217
19218
19219 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19220 PyObject *resultobj = 0;
19221 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19222 int res1 = 0 ;
19223 PyObject * obj0 = 0 ;
19224 char * kwnames[] = {
19225 (char *) "provider", NULL
19226 };
19227
19228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19229 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19230 if (!SWIG_IsOK(res1)) {
19231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19232 }
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 wxPyArtProvider::PushProvider(arg1);
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 resultobj = SWIG_Py_Void();
19240 return resultobj;
19241 fail:
19242 return NULL;
19243 }
19244
19245
19246 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19247 PyObject *resultobj = 0;
19248 bool result;
19249
19250 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19251 {
19252 PyThreadState* __tstate = wxPyBeginAllowThreads();
19253 result = (bool)wxPyArtProvider::PopProvider();
19254 wxPyEndAllowThreads(__tstate);
19255 if (PyErr_Occurred()) SWIG_fail;
19256 }
19257 {
19258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19259 }
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19267 PyObject *resultobj = 0;
19268 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19269 bool result;
19270 void *argp1 = 0 ;
19271 int res1 = 0 ;
19272 PyObject * obj0 = 0 ;
19273 char * kwnames[] = {
19274 (char *) "provider", NULL
19275 };
19276
19277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19279 if (!SWIG_IsOK(res1)) {
19280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19281 }
19282 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 {
19290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19291 }
19292 return resultobj;
19293 fail:
19294 return NULL;
19295 }
19296
19297
19298 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19299 PyObject *resultobj = 0;
19300 wxString *arg1 = 0 ;
19301 wxString const &arg2_defvalue = wxPyART_OTHER ;
19302 wxString *arg2 = (wxString *) &arg2_defvalue ;
19303 wxSize const &arg3_defvalue = wxDefaultSize ;
19304 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19305 wxBitmap result;
19306 bool temp1 = false ;
19307 bool temp2 = false ;
19308 wxSize temp3 ;
19309 PyObject * obj0 = 0 ;
19310 PyObject * obj1 = 0 ;
19311 PyObject * obj2 = 0 ;
19312 char * kwnames[] = {
19313 (char *) "id",(char *) "client",(char *) "size", NULL
19314 };
19315
19316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19317 {
19318 arg1 = wxString_in_helper(obj0);
19319 if (arg1 == NULL) SWIG_fail;
19320 temp1 = true;
19321 }
19322 if (obj1) {
19323 {
19324 arg2 = wxString_in_helper(obj1);
19325 if (arg2 == NULL) SWIG_fail;
19326 temp2 = true;
19327 }
19328 }
19329 if (obj2) {
19330 {
19331 arg3 = &temp3;
19332 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19333 }
19334 }
19335 {
19336 if (!wxPyCheckForApp()) SWIG_fail;
19337 PyThreadState* __tstate = wxPyBeginAllowThreads();
19338 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19339 wxPyEndAllowThreads(__tstate);
19340 if (PyErr_Occurred()) SWIG_fail;
19341 }
19342 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19343 {
19344 if (temp1)
19345 delete arg1;
19346 }
19347 {
19348 if (temp2)
19349 delete arg2;
19350 }
19351 return resultobj;
19352 fail:
19353 {
19354 if (temp1)
19355 delete arg1;
19356 }
19357 {
19358 if (temp2)
19359 delete arg2;
19360 }
19361 return NULL;
19362 }
19363
19364
19365 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19366 PyObject *resultobj = 0;
19367 wxString *arg1 = 0 ;
19368 wxString const &arg2_defvalue = wxPyART_OTHER ;
19369 wxString *arg2 = (wxString *) &arg2_defvalue ;
19370 wxSize const &arg3_defvalue = wxDefaultSize ;
19371 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19372 wxIcon result;
19373 bool temp1 = false ;
19374 bool temp2 = false ;
19375 wxSize temp3 ;
19376 PyObject * obj0 = 0 ;
19377 PyObject * obj1 = 0 ;
19378 PyObject * obj2 = 0 ;
19379 char * kwnames[] = {
19380 (char *) "id",(char *) "client",(char *) "size", NULL
19381 };
19382
19383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19384 {
19385 arg1 = wxString_in_helper(obj0);
19386 if (arg1 == NULL) SWIG_fail;
19387 temp1 = true;
19388 }
19389 if (obj1) {
19390 {
19391 arg2 = wxString_in_helper(obj1);
19392 if (arg2 == NULL) SWIG_fail;
19393 temp2 = true;
19394 }
19395 }
19396 if (obj2) {
19397 {
19398 arg3 = &temp3;
19399 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19400 }
19401 }
19402 {
19403 if (!wxPyCheckForApp()) SWIG_fail;
19404 PyThreadState* __tstate = wxPyBeginAllowThreads();
19405 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19406 wxPyEndAllowThreads(__tstate);
19407 if (PyErr_Occurred()) SWIG_fail;
19408 }
19409 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19410 {
19411 if (temp1)
19412 delete arg1;
19413 }
19414 {
19415 if (temp2)
19416 delete arg2;
19417 }
19418 return resultobj;
19419 fail:
19420 {
19421 if (temp1)
19422 delete arg1;
19423 }
19424 {
19425 if (temp2)
19426 delete arg2;
19427 }
19428 return NULL;
19429 }
19430
19431
19432 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj = 0;
19434 wxString *arg1 = 0 ;
19435 bool arg2 = (bool) false ;
19436 wxSize result;
19437 bool temp1 = false ;
19438 bool val2 ;
19439 int ecode2 = 0 ;
19440 PyObject * obj0 = 0 ;
19441 PyObject * obj1 = 0 ;
19442 char * kwnames[] = {
19443 (char *) "client",(char *) "platform_dependent", NULL
19444 };
19445
19446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19447 {
19448 arg1 = wxString_in_helper(obj0);
19449 if (arg1 == NULL) SWIG_fail;
19450 temp1 = true;
19451 }
19452 if (obj1) {
19453 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19454 if (!SWIG_IsOK(ecode2)) {
19455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19456 }
19457 arg2 = static_cast< bool >(val2);
19458 }
19459 {
19460 PyThreadState* __tstate = wxPyBeginAllowThreads();
19461 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19462 wxPyEndAllowThreads(__tstate);
19463 if (PyErr_Occurred()) SWIG_fail;
19464 }
19465 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19466 {
19467 if (temp1)
19468 delete arg1;
19469 }
19470 return resultobj;
19471 fail:
19472 {
19473 if (temp1)
19474 delete arg1;
19475 }
19476 return NULL;
19477 }
19478
19479
19480 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19481 PyObject *resultobj = 0;
19482 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19483 void *argp1 = 0 ;
19484 int res1 = 0 ;
19485 PyObject *swig_obj[1] ;
19486
19487 if (!args) SWIG_fail;
19488 swig_obj[0] = args;
19489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19490 if (!SWIG_IsOK(res1)) {
19491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19492 }
19493 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 wxPyArtProvider_Destroy(arg1);
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 resultobj = SWIG_Py_Void();
19501 return resultobj;
19502 fail:
19503 return NULL;
19504 }
19505
19506
19507 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19508 PyObject *obj;
19509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19510 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19511 return SWIG_Py_Void();
19512 }
19513
19514 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19515 return SWIG_Python_InitShadowInstance(args);
19516 }
19517
19518 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19519 PyObject *resultobj = 0;
19520 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19521 void *argp1 = 0 ;
19522 int res1 = 0 ;
19523 PyObject *swig_obj[1] ;
19524
19525 if (!args) SWIG_fail;
19526 swig_obj[0] = args;
19527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19528 if (!SWIG_IsOK(res1)) {
19529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19530 }
19531 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19532 {
19533 PyThreadState* __tstate = wxPyBeginAllowThreads();
19534 delete arg1;
19535
19536 wxPyEndAllowThreads(__tstate);
19537 if (PyErr_Occurred()) SWIG_fail;
19538 }
19539 resultobj = SWIG_Py_Void();
19540 return resultobj;
19541 fail:
19542 return NULL;
19543 }
19544
19545
19546 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19547 PyObject *resultobj = 0;
19548 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19549 wxConfigBase *result = 0 ;
19550 int res1 = 0 ;
19551 PyObject * obj0 = 0 ;
19552 char * kwnames[] = {
19553 (char *) "config", NULL
19554 };
19555
19556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19557 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19558 if (!SWIG_IsOK(res1)) {
19559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19560 }
19561 {
19562 PyThreadState* __tstate = wxPyBeginAllowThreads();
19563 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19564 wxPyEndAllowThreads(__tstate);
19565 if (PyErr_Occurred()) SWIG_fail;
19566 }
19567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19568 return resultobj;
19569 fail:
19570 return NULL;
19571 }
19572
19573
19574 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19575 PyObject *resultobj = 0;
19576 bool arg1 = (bool) true ;
19577 wxConfigBase *result = 0 ;
19578 bool val1 ;
19579 int ecode1 = 0 ;
19580 PyObject * obj0 = 0 ;
19581 char * kwnames[] = {
19582 (char *) "createOnDemand", NULL
19583 };
19584
19585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19586 if (obj0) {
19587 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19588 if (!SWIG_IsOK(ecode1)) {
19589 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19590 }
19591 arg1 = static_cast< bool >(val1);
19592 }
19593 {
19594 PyThreadState* __tstate = wxPyBeginAllowThreads();
19595 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19596 wxPyEndAllowThreads(__tstate);
19597 if (PyErr_Occurred()) SWIG_fail;
19598 }
19599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19600 return resultobj;
19601 fail:
19602 return NULL;
19603 }
19604
19605
19606 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19607 PyObject *resultobj = 0;
19608 wxConfigBase *result = 0 ;
19609
19610 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19611 {
19612 PyThreadState* __tstate = wxPyBeginAllowThreads();
19613 result = (wxConfigBase *)wxConfigBase::Create();
19614 wxPyEndAllowThreads(__tstate);
19615 if (PyErr_Occurred()) SWIG_fail;
19616 }
19617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19618 return resultobj;
19619 fail:
19620 return NULL;
19621 }
19622
19623
19624 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19625 PyObject *resultobj = 0;
19626
19627 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 wxConfigBase::DontCreateOnDemand();
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 *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19642 PyObject *resultobj = 0;
19643 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19644 wxString *arg2 = 0 ;
19645 void *argp1 = 0 ;
19646 int res1 = 0 ;
19647 bool temp2 = false ;
19648 PyObject * obj0 = 0 ;
19649 PyObject * obj1 = 0 ;
19650 char * kwnames[] = {
19651 (char *) "self",(char *) "path", NULL
19652 };
19653
19654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19656 if (!SWIG_IsOK(res1)) {
19657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19658 }
19659 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19660 {
19661 arg2 = wxString_in_helper(obj1);
19662 if (arg2 == NULL) SWIG_fail;
19663 temp2 = true;
19664 }
19665 {
19666 PyThreadState* __tstate = wxPyBeginAllowThreads();
19667 (arg1)->SetPath((wxString const &)*arg2);
19668 wxPyEndAllowThreads(__tstate);
19669 if (PyErr_Occurred()) SWIG_fail;
19670 }
19671 resultobj = SWIG_Py_Void();
19672 {
19673 if (temp2)
19674 delete arg2;
19675 }
19676 return resultobj;
19677 fail:
19678 {
19679 if (temp2)
19680 delete arg2;
19681 }
19682 return NULL;
19683 }
19684
19685
19686 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19687 PyObject *resultobj = 0;
19688 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19689 wxString *result = 0 ;
19690 void *argp1 = 0 ;
19691 int res1 = 0 ;
19692 PyObject *swig_obj[1] ;
19693
19694 if (!args) SWIG_fail;
19695 swig_obj[0] = args;
19696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19697 if (!SWIG_IsOK(res1)) {
19698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19699 }
19700 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19701 {
19702 PyThreadState* __tstate = wxPyBeginAllowThreads();
19703 {
19704 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19705 result = (wxString *) &_result_ref;
19706 }
19707 wxPyEndAllowThreads(__tstate);
19708 if (PyErr_Occurred()) SWIG_fail;
19709 }
19710 {
19711 #if wxUSE_UNICODE
19712 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19713 #else
19714 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19715 #endif
19716 }
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19724 PyObject *resultobj = 0;
19725 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19726 PyObject *result = 0 ;
19727 void *argp1 = 0 ;
19728 int res1 = 0 ;
19729 PyObject *swig_obj[1] ;
19730
19731 if (!args) SWIG_fail;
19732 swig_obj[0] = args;
19733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19734 if (!SWIG_IsOK(res1)) {
19735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19736 }
19737 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19738 {
19739 PyThreadState* __tstate = wxPyBeginAllowThreads();
19740 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19741 wxPyEndAllowThreads(__tstate);
19742 if (PyErr_Occurred()) SWIG_fail;
19743 }
19744 resultobj = result;
19745 return resultobj;
19746 fail:
19747 return NULL;
19748 }
19749
19750
19751 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19752 PyObject *resultobj = 0;
19753 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19754 long arg2 ;
19755 PyObject *result = 0 ;
19756 void *argp1 = 0 ;
19757 int res1 = 0 ;
19758 long val2 ;
19759 int ecode2 = 0 ;
19760 PyObject * obj0 = 0 ;
19761 PyObject * obj1 = 0 ;
19762 char * kwnames[] = {
19763 (char *) "self",(char *) "index", NULL
19764 };
19765
19766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19768 if (!SWIG_IsOK(res1)) {
19769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19770 }
19771 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19772 ecode2 = SWIG_AsVal_long(obj1, &val2);
19773 if (!SWIG_IsOK(ecode2)) {
19774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19775 }
19776 arg2 = static_cast< long >(val2);
19777 {
19778 PyThreadState* __tstate = wxPyBeginAllowThreads();
19779 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19780 wxPyEndAllowThreads(__tstate);
19781 if (PyErr_Occurred()) SWIG_fail;
19782 }
19783 resultobj = result;
19784 return resultobj;
19785 fail:
19786 return NULL;
19787 }
19788
19789
19790 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19791 PyObject *resultobj = 0;
19792 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19793 PyObject *result = 0 ;
19794 void *argp1 = 0 ;
19795 int res1 = 0 ;
19796 PyObject *swig_obj[1] ;
19797
19798 if (!args) SWIG_fail;
19799 swig_obj[0] = args;
19800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19801 if (!SWIG_IsOK(res1)) {
19802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19803 }
19804 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19805 {
19806 PyThreadState* __tstate = wxPyBeginAllowThreads();
19807 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19808 wxPyEndAllowThreads(__tstate);
19809 if (PyErr_Occurred()) SWIG_fail;
19810 }
19811 resultobj = result;
19812 return resultobj;
19813 fail:
19814 return NULL;
19815 }
19816
19817
19818 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19819 PyObject *resultobj = 0;
19820 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19821 long arg2 ;
19822 PyObject *result = 0 ;
19823 void *argp1 = 0 ;
19824 int res1 = 0 ;
19825 long val2 ;
19826 int ecode2 = 0 ;
19827 PyObject * obj0 = 0 ;
19828 PyObject * obj1 = 0 ;
19829 char * kwnames[] = {
19830 (char *) "self",(char *) "index", NULL
19831 };
19832
19833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19835 if (!SWIG_IsOK(res1)) {
19836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19837 }
19838 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19839 ecode2 = SWIG_AsVal_long(obj1, &val2);
19840 if (!SWIG_IsOK(ecode2)) {
19841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19842 }
19843 arg2 = static_cast< long >(val2);
19844 {
19845 PyThreadState* __tstate = wxPyBeginAllowThreads();
19846 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19847 wxPyEndAllowThreads(__tstate);
19848 if (PyErr_Occurred()) SWIG_fail;
19849 }
19850 resultobj = result;
19851 return resultobj;
19852 fail:
19853 return NULL;
19854 }
19855
19856
19857 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19858 PyObject *resultobj = 0;
19859 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19860 bool arg2 = (bool) false ;
19861 size_t result;
19862 void *argp1 = 0 ;
19863 int res1 = 0 ;
19864 bool val2 ;
19865 int ecode2 = 0 ;
19866 PyObject * obj0 = 0 ;
19867 PyObject * obj1 = 0 ;
19868 char * kwnames[] = {
19869 (char *) "self",(char *) "recursive", NULL
19870 };
19871
19872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19874 if (!SWIG_IsOK(res1)) {
19875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19876 }
19877 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19878 if (obj1) {
19879 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19880 if (!SWIG_IsOK(ecode2)) {
19881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19882 }
19883 arg2 = static_cast< bool >(val2);
19884 }
19885 {
19886 PyThreadState* __tstate = wxPyBeginAllowThreads();
19887 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19888 wxPyEndAllowThreads(__tstate);
19889 if (PyErr_Occurred()) SWIG_fail;
19890 }
19891 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj = 0;
19900 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19901 bool arg2 = (bool) false ;
19902 size_t result;
19903 void *argp1 = 0 ;
19904 int res1 = 0 ;
19905 bool val2 ;
19906 int ecode2 = 0 ;
19907 PyObject * obj0 = 0 ;
19908 PyObject * obj1 = 0 ;
19909 char * kwnames[] = {
19910 (char *) "self",(char *) "recursive", NULL
19911 };
19912
19913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19915 if (!SWIG_IsOK(res1)) {
19916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19917 }
19918 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19919 if (obj1) {
19920 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19921 if (!SWIG_IsOK(ecode2)) {
19922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19923 }
19924 arg2 = static_cast< bool >(val2);
19925 }
19926 {
19927 PyThreadState* __tstate = wxPyBeginAllowThreads();
19928 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19929 wxPyEndAllowThreads(__tstate);
19930 if (PyErr_Occurred()) SWIG_fail;
19931 }
19932 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19933 return resultobj;
19934 fail:
19935 return NULL;
19936 }
19937
19938
19939 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19940 PyObject *resultobj = 0;
19941 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19942 wxString *arg2 = 0 ;
19943 bool result;
19944 void *argp1 = 0 ;
19945 int res1 = 0 ;
19946 bool temp2 = false ;
19947 PyObject * obj0 = 0 ;
19948 PyObject * obj1 = 0 ;
19949 char * kwnames[] = {
19950 (char *) "self",(char *) "name", NULL
19951 };
19952
19953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19955 if (!SWIG_IsOK(res1)) {
19956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19957 }
19958 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19959 {
19960 arg2 = wxString_in_helper(obj1);
19961 if (arg2 == NULL) SWIG_fail;
19962 temp2 = true;
19963 }
19964 {
19965 PyThreadState* __tstate = wxPyBeginAllowThreads();
19966 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19967 wxPyEndAllowThreads(__tstate);
19968 if (PyErr_Occurred()) SWIG_fail;
19969 }
19970 {
19971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19972 }
19973 {
19974 if (temp2)
19975 delete arg2;
19976 }
19977 return resultobj;
19978 fail:
19979 {
19980 if (temp2)
19981 delete arg2;
19982 }
19983 return NULL;
19984 }
19985
19986
19987 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19988 PyObject *resultobj = 0;
19989 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19990 wxString *arg2 = 0 ;
19991 bool result;
19992 void *argp1 = 0 ;
19993 int res1 = 0 ;
19994 bool temp2 = false ;
19995 PyObject * obj0 = 0 ;
19996 PyObject * obj1 = 0 ;
19997 char * kwnames[] = {
19998 (char *) "self",(char *) "name", NULL
19999 };
20000
20001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20003 if (!SWIG_IsOK(res1)) {
20004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20005 }
20006 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20007 {
20008 arg2 = wxString_in_helper(obj1);
20009 if (arg2 == NULL) SWIG_fail;
20010 temp2 = true;
20011 }
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20015 wxPyEndAllowThreads(__tstate);
20016 if (PyErr_Occurred()) SWIG_fail;
20017 }
20018 {
20019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20020 }
20021 {
20022 if (temp2)
20023 delete arg2;
20024 }
20025 return resultobj;
20026 fail:
20027 {
20028 if (temp2)
20029 delete arg2;
20030 }
20031 return NULL;
20032 }
20033
20034
20035 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20036 PyObject *resultobj = 0;
20037 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20038 wxString *arg2 = 0 ;
20039 bool result;
20040 void *argp1 = 0 ;
20041 int res1 = 0 ;
20042 bool temp2 = false ;
20043 PyObject * obj0 = 0 ;
20044 PyObject * obj1 = 0 ;
20045 char * kwnames[] = {
20046 (char *) "self",(char *) "name", NULL
20047 };
20048
20049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20051 if (!SWIG_IsOK(res1)) {
20052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20053 }
20054 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20055 {
20056 arg2 = wxString_in_helper(obj1);
20057 if (arg2 == NULL) SWIG_fail;
20058 temp2 = true;
20059 }
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 {
20067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20068 }
20069 {
20070 if (temp2)
20071 delete arg2;
20072 }
20073 return resultobj;
20074 fail:
20075 {
20076 if (temp2)
20077 delete arg2;
20078 }
20079 return NULL;
20080 }
20081
20082
20083 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20084 PyObject *resultobj = 0;
20085 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20086 wxString *arg2 = 0 ;
20087 wxConfigBase::EntryType result;
20088 void *argp1 = 0 ;
20089 int res1 = 0 ;
20090 bool temp2 = false ;
20091 PyObject * obj0 = 0 ;
20092 PyObject * obj1 = 0 ;
20093 char * kwnames[] = {
20094 (char *) "self",(char *) "name", NULL
20095 };
20096
20097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20099 if (!SWIG_IsOK(res1)) {
20100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20101 }
20102 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20103 {
20104 arg2 = wxString_in_helper(obj1);
20105 if (arg2 == NULL) SWIG_fail;
20106 temp2 = true;
20107 }
20108 {
20109 PyThreadState* __tstate = wxPyBeginAllowThreads();
20110 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20111 wxPyEndAllowThreads(__tstate);
20112 if (PyErr_Occurred()) SWIG_fail;
20113 }
20114 resultobj = SWIG_From_int(static_cast< int >(result));
20115 {
20116 if (temp2)
20117 delete arg2;
20118 }
20119 return resultobj;
20120 fail:
20121 {
20122 if (temp2)
20123 delete arg2;
20124 }
20125 return NULL;
20126 }
20127
20128
20129 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20130 PyObject *resultobj = 0;
20131 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20132 wxString *arg2 = 0 ;
20133 wxString const &arg3_defvalue = wxPyEmptyString ;
20134 wxString *arg3 = (wxString *) &arg3_defvalue ;
20135 wxString result;
20136 void *argp1 = 0 ;
20137 int res1 = 0 ;
20138 bool temp2 = false ;
20139 bool temp3 = false ;
20140 PyObject * obj0 = 0 ;
20141 PyObject * obj1 = 0 ;
20142 PyObject * obj2 = 0 ;
20143 char * kwnames[] = {
20144 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20145 };
20146
20147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20149 if (!SWIG_IsOK(res1)) {
20150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20151 }
20152 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20153 {
20154 arg2 = wxString_in_helper(obj1);
20155 if (arg2 == NULL) SWIG_fail;
20156 temp2 = true;
20157 }
20158 if (obj2) {
20159 {
20160 arg3 = wxString_in_helper(obj2);
20161 if (arg3 == NULL) SWIG_fail;
20162 temp3 = true;
20163 }
20164 }
20165 {
20166 PyThreadState* __tstate = wxPyBeginAllowThreads();
20167 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20168 wxPyEndAllowThreads(__tstate);
20169 if (PyErr_Occurred()) SWIG_fail;
20170 }
20171 {
20172 #if wxUSE_UNICODE
20173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20174 #else
20175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20176 #endif
20177 }
20178 {
20179 if (temp2)
20180 delete arg2;
20181 }
20182 {
20183 if (temp3)
20184 delete arg3;
20185 }
20186 return resultobj;
20187 fail:
20188 {
20189 if (temp2)
20190 delete arg2;
20191 }
20192 {
20193 if (temp3)
20194 delete arg3;
20195 }
20196 return NULL;
20197 }
20198
20199
20200 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20201 PyObject *resultobj = 0;
20202 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20203 wxString *arg2 = 0 ;
20204 long arg3 = (long) 0 ;
20205 long result;
20206 void *argp1 = 0 ;
20207 int res1 = 0 ;
20208 bool temp2 = false ;
20209 long val3 ;
20210 int ecode3 = 0 ;
20211 PyObject * obj0 = 0 ;
20212 PyObject * obj1 = 0 ;
20213 PyObject * obj2 = 0 ;
20214 char * kwnames[] = {
20215 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20216 };
20217
20218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20220 if (!SWIG_IsOK(res1)) {
20221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20222 }
20223 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20224 {
20225 arg2 = wxString_in_helper(obj1);
20226 if (arg2 == NULL) SWIG_fail;
20227 temp2 = true;
20228 }
20229 if (obj2) {
20230 ecode3 = SWIG_AsVal_long(obj2, &val3);
20231 if (!SWIG_IsOK(ecode3)) {
20232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20233 }
20234 arg3 = static_cast< long >(val3);
20235 }
20236 {
20237 PyThreadState* __tstate = wxPyBeginAllowThreads();
20238 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20239 wxPyEndAllowThreads(__tstate);
20240 if (PyErr_Occurred()) SWIG_fail;
20241 }
20242 resultobj = SWIG_From_long(static_cast< long >(result));
20243 {
20244 if (temp2)
20245 delete arg2;
20246 }
20247 return resultobj;
20248 fail:
20249 {
20250 if (temp2)
20251 delete arg2;
20252 }
20253 return NULL;
20254 }
20255
20256
20257 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20258 PyObject *resultobj = 0;
20259 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20260 wxString *arg2 = 0 ;
20261 double arg3 = (double) 0.0 ;
20262 double result;
20263 void *argp1 = 0 ;
20264 int res1 = 0 ;
20265 bool temp2 = false ;
20266 double val3 ;
20267 int ecode3 = 0 ;
20268 PyObject * obj0 = 0 ;
20269 PyObject * obj1 = 0 ;
20270 PyObject * obj2 = 0 ;
20271 char * kwnames[] = {
20272 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20273 };
20274
20275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20277 if (!SWIG_IsOK(res1)) {
20278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20279 }
20280 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20281 {
20282 arg2 = wxString_in_helper(obj1);
20283 if (arg2 == NULL) SWIG_fail;
20284 temp2 = true;
20285 }
20286 if (obj2) {
20287 ecode3 = SWIG_AsVal_double(obj2, &val3);
20288 if (!SWIG_IsOK(ecode3)) {
20289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20290 }
20291 arg3 = static_cast< double >(val3);
20292 }
20293 {
20294 PyThreadState* __tstate = wxPyBeginAllowThreads();
20295 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20296 wxPyEndAllowThreads(__tstate);
20297 if (PyErr_Occurred()) SWIG_fail;
20298 }
20299 resultobj = SWIG_From_double(static_cast< double >(result));
20300 {
20301 if (temp2)
20302 delete arg2;
20303 }
20304 return resultobj;
20305 fail:
20306 {
20307 if (temp2)
20308 delete arg2;
20309 }
20310 return NULL;
20311 }
20312
20313
20314 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20315 PyObject *resultobj = 0;
20316 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20317 wxString *arg2 = 0 ;
20318 bool arg3 = (bool) false ;
20319 bool result;
20320 void *argp1 = 0 ;
20321 int res1 = 0 ;
20322 bool temp2 = false ;
20323 bool val3 ;
20324 int ecode3 = 0 ;
20325 PyObject * obj0 = 0 ;
20326 PyObject * obj1 = 0 ;
20327 PyObject * obj2 = 0 ;
20328 char * kwnames[] = {
20329 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20330 };
20331
20332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20334 if (!SWIG_IsOK(res1)) {
20335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20336 }
20337 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20338 {
20339 arg2 = wxString_in_helper(obj1);
20340 if (arg2 == NULL) SWIG_fail;
20341 temp2 = true;
20342 }
20343 if (obj2) {
20344 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20345 if (!SWIG_IsOK(ecode3)) {
20346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20347 }
20348 arg3 = static_cast< bool >(val3);
20349 }
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 {
20357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20358 }
20359 {
20360 if (temp2)
20361 delete arg2;
20362 }
20363 return resultobj;
20364 fail:
20365 {
20366 if (temp2)
20367 delete arg2;
20368 }
20369 return NULL;
20370 }
20371
20372
20373 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20374 PyObject *resultobj = 0;
20375 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20376 wxString *arg2 = 0 ;
20377 wxString *arg3 = 0 ;
20378 bool result;
20379 void *argp1 = 0 ;
20380 int res1 = 0 ;
20381 bool temp2 = false ;
20382 bool temp3 = false ;
20383 PyObject * obj0 = 0 ;
20384 PyObject * obj1 = 0 ;
20385 PyObject * obj2 = 0 ;
20386 char * kwnames[] = {
20387 (char *) "self",(char *) "key",(char *) "value", NULL
20388 };
20389
20390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20392 if (!SWIG_IsOK(res1)) {
20393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20394 }
20395 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20396 {
20397 arg2 = wxString_in_helper(obj1);
20398 if (arg2 == NULL) SWIG_fail;
20399 temp2 = true;
20400 }
20401 {
20402 arg3 = wxString_in_helper(obj2);
20403 if (arg3 == NULL) SWIG_fail;
20404 temp3 = true;
20405 }
20406 {
20407 PyThreadState* __tstate = wxPyBeginAllowThreads();
20408 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20409 wxPyEndAllowThreads(__tstate);
20410 if (PyErr_Occurred()) SWIG_fail;
20411 }
20412 {
20413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20414 }
20415 {
20416 if (temp2)
20417 delete arg2;
20418 }
20419 {
20420 if (temp3)
20421 delete arg3;
20422 }
20423 return resultobj;
20424 fail:
20425 {
20426 if (temp2)
20427 delete arg2;
20428 }
20429 {
20430 if (temp3)
20431 delete arg3;
20432 }
20433 return NULL;
20434 }
20435
20436
20437 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20438 PyObject *resultobj = 0;
20439 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20440 wxString *arg2 = 0 ;
20441 long arg3 ;
20442 bool result;
20443 void *argp1 = 0 ;
20444 int res1 = 0 ;
20445 bool temp2 = false ;
20446 long val3 ;
20447 int ecode3 = 0 ;
20448 PyObject * obj0 = 0 ;
20449 PyObject * obj1 = 0 ;
20450 PyObject * obj2 = 0 ;
20451 char * kwnames[] = {
20452 (char *) "self",(char *) "key",(char *) "value", NULL
20453 };
20454
20455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20457 if (!SWIG_IsOK(res1)) {
20458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20459 }
20460 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20461 {
20462 arg2 = wxString_in_helper(obj1);
20463 if (arg2 == NULL) SWIG_fail;
20464 temp2 = true;
20465 }
20466 ecode3 = SWIG_AsVal_long(obj2, &val3);
20467 if (!SWIG_IsOK(ecode3)) {
20468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20469 }
20470 arg3 = static_cast< long >(val3);
20471 {
20472 PyThreadState* __tstate = wxPyBeginAllowThreads();
20473 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20474 wxPyEndAllowThreads(__tstate);
20475 if (PyErr_Occurred()) SWIG_fail;
20476 }
20477 {
20478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20479 }
20480 {
20481 if (temp2)
20482 delete arg2;
20483 }
20484 return resultobj;
20485 fail:
20486 {
20487 if (temp2)
20488 delete arg2;
20489 }
20490 return NULL;
20491 }
20492
20493
20494 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj = 0;
20496 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20497 wxString *arg2 = 0 ;
20498 double arg3 ;
20499 bool result;
20500 void *argp1 = 0 ;
20501 int res1 = 0 ;
20502 bool temp2 = false ;
20503 double val3 ;
20504 int ecode3 = 0 ;
20505 PyObject * obj0 = 0 ;
20506 PyObject * obj1 = 0 ;
20507 PyObject * obj2 = 0 ;
20508 char * kwnames[] = {
20509 (char *) "self",(char *) "key",(char *) "value", NULL
20510 };
20511
20512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20514 if (!SWIG_IsOK(res1)) {
20515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20516 }
20517 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20518 {
20519 arg2 = wxString_in_helper(obj1);
20520 if (arg2 == NULL) SWIG_fail;
20521 temp2 = true;
20522 }
20523 ecode3 = SWIG_AsVal_double(obj2, &val3);
20524 if (!SWIG_IsOK(ecode3)) {
20525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20526 }
20527 arg3 = static_cast< double >(val3);
20528 {
20529 PyThreadState* __tstate = wxPyBeginAllowThreads();
20530 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20531 wxPyEndAllowThreads(__tstate);
20532 if (PyErr_Occurred()) SWIG_fail;
20533 }
20534 {
20535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20536 }
20537 {
20538 if (temp2)
20539 delete arg2;
20540 }
20541 return resultobj;
20542 fail:
20543 {
20544 if (temp2)
20545 delete arg2;
20546 }
20547 return NULL;
20548 }
20549
20550
20551 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20552 PyObject *resultobj = 0;
20553 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20554 wxString *arg2 = 0 ;
20555 bool arg3 ;
20556 bool result;
20557 void *argp1 = 0 ;
20558 int res1 = 0 ;
20559 bool temp2 = false ;
20560 bool val3 ;
20561 int ecode3 = 0 ;
20562 PyObject * obj0 = 0 ;
20563 PyObject * obj1 = 0 ;
20564 PyObject * obj2 = 0 ;
20565 char * kwnames[] = {
20566 (char *) "self",(char *) "key",(char *) "value", NULL
20567 };
20568
20569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20571 if (!SWIG_IsOK(res1)) {
20572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20573 }
20574 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20575 {
20576 arg2 = wxString_in_helper(obj1);
20577 if (arg2 == NULL) SWIG_fail;
20578 temp2 = true;
20579 }
20580 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20581 if (!SWIG_IsOK(ecode3)) {
20582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20583 }
20584 arg3 = static_cast< bool >(val3);
20585 {
20586 PyThreadState* __tstate = wxPyBeginAllowThreads();
20587 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20588 wxPyEndAllowThreads(__tstate);
20589 if (PyErr_Occurred()) SWIG_fail;
20590 }
20591 {
20592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20593 }
20594 {
20595 if (temp2)
20596 delete arg2;
20597 }
20598 return resultobj;
20599 fail:
20600 {
20601 if (temp2)
20602 delete arg2;
20603 }
20604 return NULL;
20605 }
20606
20607
20608 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20609 PyObject *resultobj = 0;
20610 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20611 bool arg2 = (bool) false ;
20612 bool result;
20613 void *argp1 = 0 ;
20614 int res1 = 0 ;
20615 bool val2 ;
20616 int ecode2 = 0 ;
20617 PyObject * obj0 = 0 ;
20618 PyObject * obj1 = 0 ;
20619 char * kwnames[] = {
20620 (char *) "self",(char *) "currentOnly", NULL
20621 };
20622
20623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20625 if (!SWIG_IsOK(res1)) {
20626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20627 }
20628 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20629 if (obj1) {
20630 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20631 if (!SWIG_IsOK(ecode2)) {
20632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20633 }
20634 arg2 = static_cast< bool >(val2);
20635 }
20636 {
20637 PyThreadState* __tstate = wxPyBeginAllowThreads();
20638 result = (bool)(arg1)->Flush(arg2);
20639 wxPyEndAllowThreads(__tstate);
20640 if (PyErr_Occurred()) SWIG_fail;
20641 }
20642 {
20643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20644 }
20645 return resultobj;
20646 fail:
20647 return NULL;
20648 }
20649
20650
20651 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20652 PyObject *resultobj = 0;
20653 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20654 wxString *arg2 = 0 ;
20655 wxString *arg3 = 0 ;
20656 bool result;
20657 void *argp1 = 0 ;
20658 int res1 = 0 ;
20659 bool temp2 = false ;
20660 bool temp3 = false ;
20661 PyObject * obj0 = 0 ;
20662 PyObject * obj1 = 0 ;
20663 PyObject * obj2 = 0 ;
20664 char * kwnames[] = {
20665 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20666 };
20667
20668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20670 if (!SWIG_IsOK(res1)) {
20671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20672 }
20673 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20674 {
20675 arg2 = wxString_in_helper(obj1);
20676 if (arg2 == NULL) SWIG_fail;
20677 temp2 = true;
20678 }
20679 {
20680 arg3 = wxString_in_helper(obj2);
20681 if (arg3 == NULL) SWIG_fail;
20682 temp3 = true;
20683 }
20684 {
20685 PyThreadState* __tstate = wxPyBeginAllowThreads();
20686 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20687 wxPyEndAllowThreads(__tstate);
20688 if (PyErr_Occurred()) SWIG_fail;
20689 }
20690 {
20691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20692 }
20693 {
20694 if (temp2)
20695 delete arg2;
20696 }
20697 {
20698 if (temp3)
20699 delete arg3;
20700 }
20701 return resultobj;
20702 fail:
20703 {
20704 if (temp2)
20705 delete arg2;
20706 }
20707 {
20708 if (temp3)
20709 delete arg3;
20710 }
20711 return NULL;
20712 }
20713
20714
20715 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20716 PyObject *resultobj = 0;
20717 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20718 wxString *arg2 = 0 ;
20719 wxString *arg3 = 0 ;
20720 bool result;
20721 void *argp1 = 0 ;
20722 int res1 = 0 ;
20723 bool temp2 = false ;
20724 bool temp3 = false ;
20725 PyObject * obj0 = 0 ;
20726 PyObject * obj1 = 0 ;
20727 PyObject * obj2 = 0 ;
20728 char * kwnames[] = {
20729 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20730 };
20731
20732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20734 if (!SWIG_IsOK(res1)) {
20735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20736 }
20737 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20738 {
20739 arg2 = wxString_in_helper(obj1);
20740 if (arg2 == NULL) SWIG_fail;
20741 temp2 = true;
20742 }
20743 {
20744 arg3 = wxString_in_helper(obj2);
20745 if (arg3 == NULL) SWIG_fail;
20746 temp3 = true;
20747 }
20748 {
20749 PyThreadState* __tstate = wxPyBeginAllowThreads();
20750 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20751 wxPyEndAllowThreads(__tstate);
20752 if (PyErr_Occurred()) SWIG_fail;
20753 }
20754 {
20755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20756 }
20757 {
20758 if (temp2)
20759 delete arg2;
20760 }
20761 {
20762 if (temp3)
20763 delete arg3;
20764 }
20765 return resultobj;
20766 fail:
20767 {
20768 if (temp2)
20769 delete arg2;
20770 }
20771 {
20772 if (temp3)
20773 delete arg3;
20774 }
20775 return NULL;
20776 }
20777
20778
20779 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20780 PyObject *resultobj = 0;
20781 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20782 wxString *arg2 = 0 ;
20783 bool arg3 = (bool) true ;
20784 bool result;
20785 void *argp1 = 0 ;
20786 int res1 = 0 ;
20787 bool temp2 = false ;
20788 bool val3 ;
20789 int ecode3 = 0 ;
20790 PyObject * obj0 = 0 ;
20791 PyObject * obj1 = 0 ;
20792 PyObject * obj2 = 0 ;
20793 char * kwnames[] = {
20794 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20795 };
20796
20797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20799 if (!SWIG_IsOK(res1)) {
20800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20801 }
20802 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20803 {
20804 arg2 = wxString_in_helper(obj1);
20805 if (arg2 == NULL) SWIG_fail;
20806 temp2 = true;
20807 }
20808 if (obj2) {
20809 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20810 if (!SWIG_IsOK(ecode3)) {
20811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20812 }
20813 arg3 = static_cast< bool >(val3);
20814 }
20815 {
20816 PyThreadState* __tstate = wxPyBeginAllowThreads();
20817 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20818 wxPyEndAllowThreads(__tstate);
20819 if (PyErr_Occurred()) SWIG_fail;
20820 }
20821 {
20822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20823 }
20824 {
20825 if (temp2)
20826 delete arg2;
20827 }
20828 return resultobj;
20829 fail:
20830 {
20831 if (temp2)
20832 delete arg2;
20833 }
20834 return NULL;
20835 }
20836
20837
20838 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20839 PyObject *resultobj = 0;
20840 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20841 wxString *arg2 = 0 ;
20842 bool result;
20843 void *argp1 = 0 ;
20844 int res1 = 0 ;
20845 bool temp2 = false ;
20846 PyObject * obj0 = 0 ;
20847 PyObject * obj1 = 0 ;
20848 char * kwnames[] = {
20849 (char *) "self",(char *) "key", NULL
20850 };
20851
20852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20854 if (!SWIG_IsOK(res1)) {
20855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20856 }
20857 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20858 {
20859 arg2 = wxString_in_helper(obj1);
20860 if (arg2 == NULL) SWIG_fail;
20861 temp2 = true;
20862 }
20863 {
20864 PyThreadState* __tstate = wxPyBeginAllowThreads();
20865 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20866 wxPyEndAllowThreads(__tstate);
20867 if (PyErr_Occurred()) SWIG_fail;
20868 }
20869 {
20870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20871 }
20872 {
20873 if (temp2)
20874 delete arg2;
20875 }
20876 return resultobj;
20877 fail:
20878 {
20879 if (temp2)
20880 delete arg2;
20881 }
20882 return NULL;
20883 }
20884
20885
20886 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20887 PyObject *resultobj = 0;
20888 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20889 bool result;
20890 void *argp1 = 0 ;
20891 int res1 = 0 ;
20892 PyObject *swig_obj[1] ;
20893
20894 if (!args) SWIG_fail;
20895 swig_obj[0] = args;
20896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20897 if (!SWIG_IsOK(res1)) {
20898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20899 }
20900 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20901 {
20902 PyThreadState* __tstate = wxPyBeginAllowThreads();
20903 result = (bool)(arg1)->DeleteAll();
20904 wxPyEndAllowThreads(__tstate);
20905 if (PyErr_Occurred()) SWIG_fail;
20906 }
20907 {
20908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20909 }
20910 return resultobj;
20911 fail:
20912 return NULL;
20913 }
20914
20915
20916 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20917 PyObject *resultobj = 0;
20918 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20919 bool arg2 = (bool) true ;
20920 void *argp1 = 0 ;
20921 int res1 = 0 ;
20922 bool val2 ;
20923 int ecode2 = 0 ;
20924 PyObject * obj0 = 0 ;
20925 PyObject * obj1 = 0 ;
20926 char * kwnames[] = {
20927 (char *) "self",(char *) "doIt", NULL
20928 };
20929
20930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20932 if (!SWIG_IsOK(res1)) {
20933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20934 }
20935 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20936 if (obj1) {
20937 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20938 if (!SWIG_IsOK(ecode2)) {
20939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20940 }
20941 arg2 = static_cast< bool >(val2);
20942 }
20943 {
20944 PyThreadState* __tstate = wxPyBeginAllowThreads();
20945 (arg1)->SetExpandEnvVars(arg2);
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 resultobj = SWIG_Py_Void();
20950 return resultobj;
20951 fail:
20952 return NULL;
20953 }
20954
20955
20956 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20957 PyObject *resultobj = 0;
20958 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20959 bool result;
20960 void *argp1 = 0 ;
20961 int res1 = 0 ;
20962 PyObject *swig_obj[1] ;
20963
20964 if (!args) SWIG_fail;
20965 swig_obj[0] = args;
20966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20967 if (!SWIG_IsOK(res1)) {
20968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20969 }
20970 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20971 {
20972 PyThreadState* __tstate = wxPyBeginAllowThreads();
20973 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20974 wxPyEndAllowThreads(__tstate);
20975 if (PyErr_Occurred()) SWIG_fail;
20976 }
20977 {
20978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20979 }
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20987 PyObject *resultobj = 0;
20988 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20989 bool arg2 = (bool) true ;
20990 void *argp1 = 0 ;
20991 int res1 = 0 ;
20992 bool val2 ;
20993 int ecode2 = 0 ;
20994 PyObject * obj0 = 0 ;
20995 PyObject * obj1 = 0 ;
20996 char * kwnames[] = {
20997 (char *) "self",(char *) "doIt", NULL
20998 };
20999
21000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21002 if (!SWIG_IsOK(res1)) {
21003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21004 }
21005 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21006 if (obj1) {
21007 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21008 if (!SWIG_IsOK(ecode2)) {
21009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21010 }
21011 arg2 = static_cast< bool >(val2);
21012 }
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 (arg1)->SetRecordDefaults(arg2);
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 resultobj = SWIG_Py_Void();
21020 return resultobj;
21021 fail:
21022 return NULL;
21023 }
21024
21025
21026 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21027 PyObject *resultobj = 0;
21028 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21029 bool result;
21030 void *argp1 = 0 ;
21031 int res1 = 0 ;
21032 PyObject *swig_obj[1] ;
21033
21034 if (!args) SWIG_fail;
21035 swig_obj[0] = args;
21036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21037 if (!SWIG_IsOK(res1)) {
21038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21039 }
21040 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21041 {
21042 PyThreadState* __tstate = wxPyBeginAllowThreads();
21043 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21044 wxPyEndAllowThreads(__tstate);
21045 if (PyErr_Occurred()) SWIG_fail;
21046 }
21047 {
21048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21049 }
21050 return resultobj;
21051 fail:
21052 return NULL;
21053 }
21054
21055
21056 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21057 PyObject *resultobj = 0;
21058 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21059 wxString *arg2 = 0 ;
21060 wxString result;
21061 void *argp1 = 0 ;
21062 int res1 = 0 ;
21063 bool temp2 = false ;
21064 PyObject * obj0 = 0 ;
21065 PyObject * obj1 = 0 ;
21066 char * kwnames[] = {
21067 (char *) "self",(char *) "str", NULL
21068 };
21069
21070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21072 if (!SWIG_IsOK(res1)) {
21073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21074 }
21075 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21076 {
21077 arg2 = wxString_in_helper(obj1);
21078 if (arg2 == NULL) SWIG_fail;
21079 temp2 = true;
21080 }
21081 {
21082 PyThreadState* __tstate = wxPyBeginAllowThreads();
21083 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21084 wxPyEndAllowThreads(__tstate);
21085 if (PyErr_Occurred()) SWIG_fail;
21086 }
21087 {
21088 #if wxUSE_UNICODE
21089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21090 #else
21091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21092 #endif
21093 }
21094 {
21095 if (temp2)
21096 delete arg2;
21097 }
21098 return resultobj;
21099 fail:
21100 {
21101 if (temp2)
21102 delete arg2;
21103 }
21104 return NULL;
21105 }
21106
21107
21108 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21109 PyObject *resultobj = 0;
21110 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21111 wxString result;
21112 void *argp1 = 0 ;
21113 int res1 = 0 ;
21114 PyObject *swig_obj[1] ;
21115
21116 if (!args) SWIG_fail;
21117 swig_obj[0] = args;
21118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21119 if (!SWIG_IsOK(res1)) {
21120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21121 }
21122 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = ((wxConfigBase const *)arg1)->GetAppName();
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 {
21130 #if wxUSE_UNICODE
21131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21132 #else
21133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21134 #endif
21135 }
21136 return resultobj;
21137 fail:
21138 return NULL;
21139 }
21140
21141
21142 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21143 PyObject *resultobj = 0;
21144 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21145 wxString result;
21146 void *argp1 = 0 ;
21147 int res1 = 0 ;
21148 PyObject *swig_obj[1] ;
21149
21150 if (!args) SWIG_fail;
21151 swig_obj[0] = args;
21152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21153 if (!SWIG_IsOK(res1)) {
21154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21155 }
21156 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21157 {
21158 PyThreadState* __tstate = wxPyBeginAllowThreads();
21159 result = ((wxConfigBase const *)arg1)->GetVendorName();
21160 wxPyEndAllowThreads(__tstate);
21161 if (PyErr_Occurred()) SWIG_fail;
21162 }
21163 {
21164 #if wxUSE_UNICODE
21165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21166 #else
21167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21168 #endif
21169 }
21170 return resultobj;
21171 fail:
21172 return NULL;
21173 }
21174
21175
21176 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21177 PyObject *resultobj = 0;
21178 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21179 wxString *arg2 = 0 ;
21180 void *argp1 = 0 ;
21181 int res1 = 0 ;
21182 bool temp2 = false ;
21183 PyObject * obj0 = 0 ;
21184 PyObject * obj1 = 0 ;
21185 char * kwnames[] = {
21186 (char *) "self",(char *) "appName", NULL
21187 };
21188
21189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21191 if (!SWIG_IsOK(res1)) {
21192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21193 }
21194 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21195 {
21196 arg2 = wxString_in_helper(obj1);
21197 if (arg2 == NULL) SWIG_fail;
21198 temp2 = true;
21199 }
21200 {
21201 PyThreadState* __tstate = wxPyBeginAllowThreads();
21202 (arg1)->SetAppName((wxString const &)*arg2);
21203 wxPyEndAllowThreads(__tstate);
21204 if (PyErr_Occurred()) SWIG_fail;
21205 }
21206 resultobj = SWIG_Py_Void();
21207 {
21208 if (temp2)
21209 delete arg2;
21210 }
21211 return resultobj;
21212 fail:
21213 {
21214 if (temp2)
21215 delete arg2;
21216 }
21217 return NULL;
21218 }
21219
21220
21221 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21222 PyObject *resultobj = 0;
21223 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21224 wxString *arg2 = 0 ;
21225 void *argp1 = 0 ;
21226 int res1 = 0 ;
21227 bool temp2 = false ;
21228 PyObject * obj0 = 0 ;
21229 PyObject * obj1 = 0 ;
21230 char * kwnames[] = {
21231 (char *) "self",(char *) "vendorName", NULL
21232 };
21233
21234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21236 if (!SWIG_IsOK(res1)) {
21237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21238 }
21239 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21240 {
21241 arg2 = wxString_in_helper(obj1);
21242 if (arg2 == NULL) SWIG_fail;
21243 temp2 = true;
21244 }
21245 {
21246 PyThreadState* __tstate = wxPyBeginAllowThreads();
21247 (arg1)->SetVendorName((wxString const &)*arg2);
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 resultobj = SWIG_Py_Void();
21252 {
21253 if (temp2)
21254 delete arg2;
21255 }
21256 return resultobj;
21257 fail:
21258 {
21259 if (temp2)
21260 delete arg2;
21261 }
21262 return NULL;
21263 }
21264
21265
21266 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21267 PyObject *resultobj = 0;
21268 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21269 long arg2 ;
21270 void *argp1 = 0 ;
21271 int res1 = 0 ;
21272 long val2 ;
21273 int ecode2 = 0 ;
21274 PyObject * obj0 = 0 ;
21275 PyObject * obj1 = 0 ;
21276 char * kwnames[] = {
21277 (char *) "self",(char *) "style", NULL
21278 };
21279
21280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21282 if (!SWIG_IsOK(res1)) {
21283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21284 }
21285 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21286 ecode2 = SWIG_AsVal_long(obj1, &val2);
21287 if (!SWIG_IsOK(ecode2)) {
21288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21289 }
21290 arg2 = static_cast< long >(val2);
21291 {
21292 PyThreadState* __tstate = wxPyBeginAllowThreads();
21293 (arg1)->SetStyle(arg2);
21294 wxPyEndAllowThreads(__tstate);
21295 if (PyErr_Occurred()) SWIG_fail;
21296 }
21297 resultobj = SWIG_Py_Void();
21298 return resultobj;
21299 fail:
21300 return NULL;
21301 }
21302
21303
21304 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21305 PyObject *resultobj = 0;
21306 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21307 long result;
21308 void *argp1 = 0 ;
21309 int res1 = 0 ;
21310 PyObject *swig_obj[1] ;
21311
21312 if (!args) SWIG_fail;
21313 swig_obj[0] = args;
21314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21315 if (!SWIG_IsOK(res1)) {
21316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21317 }
21318 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21319 {
21320 PyThreadState* __tstate = wxPyBeginAllowThreads();
21321 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21322 wxPyEndAllowThreads(__tstate);
21323 if (PyErr_Occurred()) SWIG_fail;
21324 }
21325 resultobj = SWIG_From_long(static_cast< long >(result));
21326 return resultobj;
21327 fail:
21328 return NULL;
21329 }
21330
21331
21332 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21333 PyObject *obj;
21334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21335 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21336 return SWIG_Py_Void();
21337 }
21338
21339 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj = 0;
21341 wxString const &arg1_defvalue = wxPyEmptyString ;
21342 wxString *arg1 = (wxString *) &arg1_defvalue ;
21343 wxString const &arg2_defvalue = wxPyEmptyString ;
21344 wxString *arg2 = (wxString *) &arg2_defvalue ;
21345 wxString const &arg3_defvalue = wxPyEmptyString ;
21346 wxString *arg3 = (wxString *) &arg3_defvalue ;
21347 wxString const &arg4_defvalue = wxPyEmptyString ;
21348 wxString *arg4 = (wxString *) &arg4_defvalue ;
21349 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21350 wxConfig *result = 0 ;
21351 bool temp1 = false ;
21352 bool temp2 = false ;
21353 bool temp3 = false ;
21354 bool temp4 = false ;
21355 long val5 ;
21356 int ecode5 = 0 ;
21357 PyObject * obj0 = 0 ;
21358 PyObject * obj1 = 0 ;
21359 PyObject * obj2 = 0 ;
21360 PyObject * obj3 = 0 ;
21361 PyObject * obj4 = 0 ;
21362 char * kwnames[] = {
21363 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21364 };
21365
21366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21367 if (obj0) {
21368 {
21369 arg1 = wxString_in_helper(obj0);
21370 if (arg1 == NULL) SWIG_fail;
21371 temp1 = true;
21372 }
21373 }
21374 if (obj1) {
21375 {
21376 arg2 = wxString_in_helper(obj1);
21377 if (arg2 == NULL) SWIG_fail;
21378 temp2 = true;
21379 }
21380 }
21381 if (obj2) {
21382 {
21383 arg3 = wxString_in_helper(obj2);
21384 if (arg3 == NULL) SWIG_fail;
21385 temp3 = true;
21386 }
21387 }
21388 if (obj3) {
21389 {
21390 arg4 = wxString_in_helper(obj3);
21391 if (arg4 == NULL) SWIG_fail;
21392 temp4 = true;
21393 }
21394 }
21395 if (obj4) {
21396 ecode5 = SWIG_AsVal_long(obj4, &val5);
21397 if (!SWIG_IsOK(ecode5)) {
21398 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21399 }
21400 arg5 = static_cast< long >(val5);
21401 }
21402 {
21403 PyThreadState* __tstate = wxPyBeginAllowThreads();
21404 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21405 wxPyEndAllowThreads(__tstate);
21406 if (PyErr_Occurred()) SWIG_fail;
21407 }
21408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21409 {
21410 if (temp1)
21411 delete arg1;
21412 }
21413 {
21414 if (temp2)
21415 delete arg2;
21416 }
21417 {
21418 if (temp3)
21419 delete arg3;
21420 }
21421 {
21422 if (temp4)
21423 delete arg4;
21424 }
21425 return resultobj;
21426 fail:
21427 {
21428 if (temp1)
21429 delete arg1;
21430 }
21431 {
21432 if (temp2)
21433 delete arg2;
21434 }
21435 {
21436 if (temp3)
21437 delete arg3;
21438 }
21439 {
21440 if (temp4)
21441 delete arg4;
21442 }
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21448 PyObject *resultobj = 0;
21449 wxConfig *arg1 = (wxConfig *) 0 ;
21450 void *argp1 = 0 ;
21451 int res1 = 0 ;
21452 PyObject *swig_obj[1] ;
21453
21454 if (!args) SWIG_fail;
21455 swig_obj[0] = args;
21456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21457 if (!SWIG_IsOK(res1)) {
21458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21459 }
21460 arg1 = reinterpret_cast< wxConfig * >(argp1);
21461 {
21462 PyThreadState* __tstate = wxPyBeginAllowThreads();
21463 delete arg1;
21464
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 resultobj = SWIG_Py_Void();
21469 return resultobj;
21470 fail:
21471 return NULL;
21472 }
21473
21474
21475 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21476 PyObject *obj;
21477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21478 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21479 return SWIG_Py_Void();
21480 }
21481
21482 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21483 return SWIG_Python_InitShadowInstance(args);
21484 }
21485
21486 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21487 PyObject *resultobj = 0;
21488 wxString const &arg1_defvalue = wxPyEmptyString ;
21489 wxString *arg1 = (wxString *) &arg1_defvalue ;
21490 wxString const &arg2_defvalue = wxPyEmptyString ;
21491 wxString *arg2 = (wxString *) &arg2_defvalue ;
21492 wxString const &arg3_defvalue = wxPyEmptyString ;
21493 wxString *arg3 = (wxString *) &arg3_defvalue ;
21494 wxString const &arg4_defvalue = wxPyEmptyString ;
21495 wxString *arg4 = (wxString *) &arg4_defvalue ;
21496 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21497 wxFileConfig *result = 0 ;
21498 bool temp1 = false ;
21499 bool temp2 = false ;
21500 bool temp3 = false ;
21501 bool temp4 = false ;
21502 long val5 ;
21503 int ecode5 = 0 ;
21504 PyObject * obj0 = 0 ;
21505 PyObject * obj1 = 0 ;
21506 PyObject * obj2 = 0 ;
21507 PyObject * obj3 = 0 ;
21508 PyObject * obj4 = 0 ;
21509 char * kwnames[] = {
21510 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21511 };
21512
21513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21514 if (obj0) {
21515 {
21516 arg1 = wxString_in_helper(obj0);
21517 if (arg1 == NULL) SWIG_fail;
21518 temp1 = true;
21519 }
21520 }
21521 if (obj1) {
21522 {
21523 arg2 = wxString_in_helper(obj1);
21524 if (arg2 == NULL) SWIG_fail;
21525 temp2 = true;
21526 }
21527 }
21528 if (obj2) {
21529 {
21530 arg3 = wxString_in_helper(obj2);
21531 if (arg3 == NULL) SWIG_fail;
21532 temp3 = true;
21533 }
21534 }
21535 if (obj3) {
21536 {
21537 arg4 = wxString_in_helper(obj3);
21538 if (arg4 == NULL) SWIG_fail;
21539 temp4 = true;
21540 }
21541 }
21542 if (obj4) {
21543 ecode5 = SWIG_AsVal_long(obj4, &val5);
21544 if (!SWIG_IsOK(ecode5)) {
21545 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21546 }
21547 arg5 = static_cast< long >(val5);
21548 }
21549 {
21550 PyThreadState* __tstate = wxPyBeginAllowThreads();
21551 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21552 wxPyEndAllowThreads(__tstate);
21553 if (PyErr_Occurred()) SWIG_fail;
21554 }
21555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21556 {
21557 if (temp1)
21558 delete arg1;
21559 }
21560 {
21561 if (temp2)
21562 delete arg2;
21563 }
21564 {
21565 if (temp3)
21566 delete arg3;
21567 }
21568 {
21569 if (temp4)
21570 delete arg4;
21571 }
21572 return resultobj;
21573 fail:
21574 {
21575 if (temp1)
21576 delete arg1;
21577 }
21578 {
21579 if (temp2)
21580 delete arg2;
21581 }
21582 {
21583 if (temp3)
21584 delete arg3;
21585 }
21586 {
21587 if (temp4)
21588 delete arg4;
21589 }
21590 return NULL;
21591 }
21592
21593
21594 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21595 PyObject *resultobj = 0;
21596 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21597 void *argp1 = 0 ;
21598 int res1 = 0 ;
21599 PyObject *swig_obj[1] ;
21600
21601 if (!args) SWIG_fail;
21602 swig_obj[0] = args;
21603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21604 if (!SWIG_IsOK(res1)) {
21605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21606 }
21607 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21608 {
21609 PyThreadState* __tstate = wxPyBeginAllowThreads();
21610 delete arg1;
21611
21612 wxPyEndAllowThreads(__tstate);
21613 if (PyErr_Occurred()) SWIG_fail;
21614 }
21615 resultobj = SWIG_Py_Void();
21616 return resultobj;
21617 fail:
21618 return NULL;
21619 }
21620
21621
21622 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21623 PyObject *obj;
21624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21625 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21626 return SWIG_Py_Void();
21627 }
21628
21629 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21630 return SWIG_Python_InitShadowInstance(args);
21631 }
21632
21633 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21634 PyObject *resultobj = 0;
21635 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21636 wxString *arg2 = 0 ;
21637 wxConfigPathChanger *result = 0 ;
21638 void *argp1 = 0 ;
21639 int res1 = 0 ;
21640 bool temp2 = false ;
21641 PyObject * obj0 = 0 ;
21642 PyObject * obj1 = 0 ;
21643 char * kwnames[] = {
21644 (char *) "config",(char *) "entry", NULL
21645 };
21646
21647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21649 if (!SWIG_IsOK(res1)) {
21650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21651 }
21652 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21653 {
21654 arg2 = wxString_in_helper(obj1);
21655 if (arg2 == NULL) SWIG_fail;
21656 temp2 = true;
21657 }
21658 {
21659 PyThreadState* __tstate = wxPyBeginAllowThreads();
21660 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21661 wxPyEndAllowThreads(__tstate);
21662 if (PyErr_Occurred()) SWIG_fail;
21663 }
21664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21665 {
21666 if (temp2)
21667 delete arg2;
21668 }
21669 return resultobj;
21670 fail:
21671 {
21672 if (temp2)
21673 delete arg2;
21674 }
21675 return NULL;
21676 }
21677
21678
21679 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21680 PyObject *resultobj = 0;
21681 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21682 void *argp1 = 0 ;
21683 int res1 = 0 ;
21684 PyObject *swig_obj[1] ;
21685
21686 if (!args) SWIG_fail;
21687 swig_obj[0] = args;
21688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21689 if (!SWIG_IsOK(res1)) {
21690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21691 }
21692 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21693 {
21694 PyThreadState* __tstate = wxPyBeginAllowThreads();
21695 delete arg1;
21696
21697 wxPyEndAllowThreads(__tstate);
21698 if (PyErr_Occurred()) SWIG_fail;
21699 }
21700 resultobj = SWIG_Py_Void();
21701 return resultobj;
21702 fail:
21703 return NULL;
21704 }
21705
21706
21707 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21708 PyObject *resultobj = 0;
21709 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21710 wxString *result = 0 ;
21711 void *argp1 = 0 ;
21712 int res1 = 0 ;
21713 PyObject *swig_obj[1] ;
21714
21715 if (!args) SWIG_fail;
21716 swig_obj[0] = args;
21717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21718 if (!SWIG_IsOK(res1)) {
21719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21720 }
21721 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21722 {
21723 PyThreadState* __tstate = wxPyBeginAllowThreads();
21724 {
21725 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21726 result = (wxString *) &_result_ref;
21727 }
21728 wxPyEndAllowThreads(__tstate);
21729 if (PyErr_Occurred()) SWIG_fail;
21730 }
21731 {
21732 #if wxUSE_UNICODE
21733 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21734 #else
21735 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21736 #endif
21737 }
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21745 PyObject *obj;
21746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21747 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21748 return SWIG_Py_Void();
21749 }
21750
21751 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21752 return SWIG_Python_InitShadowInstance(args);
21753 }
21754
21755 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21756 PyObject *resultobj = 0;
21757 wxString *arg1 = 0 ;
21758 wxString result;
21759 bool temp1 = false ;
21760 PyObject * obj0 = 0 ;
21761 char * kwnames[] = {
21762 (char *) "sz", NULL
21763 };
21764
21765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21766 {
21767 arg1 = wxString_in_helper(obj0);
21768 if (arg1 == NULL) SWIG_fail;
21769 temp1 = true;
21770 }
21771 {
21772 PyThreadState* __tstate = wxPyBeginAllowThreads();
21773 result = wxExpandEnvVars((wxString const &)*arg1);
21774 wxPyEndAllowThreads(__tstate);
21775 if (PyErr_Occurred()) SWIG_fail;
21776 }
21777 {
21778 #if wxUSE_UNICODE
21779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21780 #else
21781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21782 #endif
21783 }
21784 {
21785 if (temp1)
21786 delete arg1;
21787 }
21788 return resultobj;
21789 fail:
21790 {
21791 if (temp1)
21792 delete arg1;
21793 }
21794 return NULL;
21795 }
21796
21797
21798 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21799 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21800 return 1;
21801 }
21802
21803
21804 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21805 PyObject *pyobj = 0;
21806
21807 {
21808 #if wxUSE_UNICODE
21809 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21810 #else
21811 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21812 #endif
21813 }
21814 return pyobj;
21815 }
21816
21817
21818 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21819 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21820 return 1;
21821 }
21822
21823
21824 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21825 PyObject *pyobj = 0;
21826
21827 {
21828 #if wxUSE_UNICODE
21829 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21830 #else
21831 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21832 #endif
21833 }
21834 return pyobj;
21835 }
21836
21837
21838 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21839 PyObject *resultobj = 0;
21840 wxDateTime::Country arg1 ;
21841 int val1 ;
21842 int ecode1 = 0 ;
21843 PyObject * obj0 = 0 ;
21844 char * kwnames[] = {
21845 (char *) "country", NULL
21846 };
21847
21848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21849 ecode1 = SWIG_AsVal_int(obj0, &val1);
21850 if (!SWIG_IsOK(ecode1)) {
21851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21852 }
21853 arg1 = static_cast< wxDateTime::Country >(val1);
21854 {
21855 PyThreadState* __tstate = wxPyBeginAllowThreads();
21856 wxDateTime::SetCountry(arg1);
21857 wxPyEndAllowThreads(__tstate);
21858 if (PyErr_Occurred()) SWIG_fail;
21859 }
21860 resultobj = SWIG_Py_Void();
21861 return resultobj;
21862 fail:
21863 return NULL;
21864 }
21865
21866
21867 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21868 PyObject *resultobj = 0;
21869 wxDateTime::Country result;
21870
21871 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21872 {
21873 PyThreadState* __tstate = wxPyBeginAllowThreads();
21874 result = (wxDateTime::Country)wxDateTime::GetCountry();
21875 wxPyEndAllowThreads(__tstate);
21876 if (PyErr_Occurred()) SWIG_fail;
21877 }
21878 resultobj = SWIG_From_int(static_cast< int >(result));
21879 return resultobj;
21880 fail:
21881 return NULL;
21882 }
21883
21884
21885 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21886 PyObject *resultobj = 0;
21887 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21888 bool result;
21889 int val1 ;
21890 int ecode1 = 0 ;
21891 PyObject * obj0 = 0 ;
21892 char * kwnames[] = {
21893 (char *) "country", NULL
21894 };
21895
21896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21897 if (obj0) {
21898 ecode1 = SWIG_AsVal_int(obj0, &val1);
21899 if (!SWIG_IsOK(ecode1)) {
21900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21901 }
21902 arg1 = static_cast< wxDateTime::Country >(val1);
21903 }
21904 {
21905 PyThreadState* __tstate = wxPyBeginAllowThreads();
21906 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21907 wxPyEndAllowThreads(__tstate);
21908 if (PyErr_Occurred()) SWIG_fail;
21909 }
21910 {
21911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21912 }
21913 return resultobj;
21914 fail:
21915 return NULL;
21916 }
21917
21918
21919 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21920 PyObject *resultobj = 0;
21921 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21922 int result;
21923 int val1 ;
21924 int ecode1 = 0 ;
21925 PyObject * obj0 = 0 ;
21926 char * kwnames[] = {
21927 (char *) "cal", NULL
21928 };
21929
21930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21931 if (obj0) {
21932 ecode1 = SWIG_AsVal_int(obj0, &val1);
21933 if (!SWIG_IsOK(ecode1)) {
21934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21935 }
21936 arg1 = static_cast< wxDateTime::Calendar >(val1);
21937 }
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 result = (int)wxDateTime::GetCurrentYear(arg1);
21941 wxPyEndAllowThreads(__tstate);
21942 if (PyErr_Occurred()) SWIG_fail;
21943 }
21944 resultobj = SWIG_From_int(static_cast< int >(result));
21945 return resultobj;
21946 fail:
21947 return NULL;
21948 }
21949
21950
21951 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21952 PyObject *resultobj = 0;
21953 int arg1 ;
21954 int result;
21955 int val1 ;
21956 int ecode1 = 0 ;
21957 PyObject * obj0 = 0 ;
21958 char * kwnames[] = {
21959 (char *) "year", NULL
21960 };
21961
21962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21963 ecode1 = SWIG_AsVal_int(obj0, &val1);
21964 if (!SWIG_IsOK(ecode1)) {
21965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21966 }
21967 arg1 = static_cast< int >(val1);
21968 {
21969 PyThreadState* __tstate = wxPyBeginAllowThreads();
21970 result = (int)wxDateTime::ConvertYearToBC(arg1);
21971 wxPyEndAllowThreads(__tstate);
21972 if (PyErr_Occurred()) SWIG_fail;
21973 }
21974 resultobj = SWIG_From_int(static_cast< int >(result));
21975 return resultobj;
21976 fail:
21977 return NULL;
21978 }
21979
21980
21981 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21982 PyObject *resultobj = 0;
21983 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21984 wxDateTime::Month result;
21985 int val1 ;
21986 int ecode1 = 0 ;
21987 PyObject * obj0 = 0 ;
21988 char * kwnames[] = {
21989 (char *) "cal", NULL
21990 };
21991
21992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
21993 if (obj0) {
21994 ecode1 = SWIG_AsVal_int(obj0, &val1);
21995 if (!SWIG_IsOK(ecode1)) {
21996 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21997 }
21998 arg1 = static_cast< wxDateTime::Calendar >(val1);
21999 }
22000 {
22001 PyThreadState* __tstate = wxPyBeginAllowThreads();
22002 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22003 wxPyEndAllowThreads(__tstate);
22004 if (PyErr_Occurred()) SWIG_fail;
22005 }
22006 resultobj = SWIG_From_int(static_cast< int >(result));
22007 return resultobj;
22008 fail:
22009 return NULL;
22010 }
22011
22012
22013 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22014 PyObject *resultobj = 0;
22015 int arg1 = (int) wxDateTime::Inv_Year ;
22016 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22017 bool result;
22018 int val1 ;
22019 int ecode1 = 0 ;
22020 int val2 ;
22021 int ecode2 = 0 ;
22022 PyObject * obj0 = 0 ;
22023 PyObject * obj1 = 0 ;
22024 char * kwnames[] = {
22025 (char *) "year",(char *) "cal", NULL
22026 };
22027
22028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22029 if (obj0) {
22030 ecode1 = SWIG_AsVal_int(obj0, &val1);
22031 if (!SWIG_IsOK(ecode1)) {
22032 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22033 }
22034 arg1 = static_cast< int >(val1);
22035 }
22036 if (obj1) {
22037 ecode2 = SWIG_AsVal_int(obj1, &val2);
22038 if (!SWIG_IsOK(ecode2)) {
22039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22040 }
22041 arg2 = static_cast< wxDateTime::Calendar >(val2);
22042 }
22043 {
22044 PyThreadState* __tstate = wxPyBeginAllowThreads();
22045 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22046 wxPyEndAllowThreads(__tstate);
22047 if (PyErr_Occurred()) SWIG_fail;
22048 }
22049 {
22050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22051 }
22052 return resultobj;
22053 fail:
22054 return NULL;
22055 }
22056
22057
22058 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22059 PyObject *resultobj = 0;
22060 int arg1 = (int) wxDateTime::Inv_Year ;
22061 int result;
22062 int val1 ;
22063 int ecode1 = 0 ;
22064 PyObject * obj0 = 0 ;
22065 char * kwnames[] = {
22066 (char *) "year", NULL
22067 };
22068
22069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22070 if (obj0) {
22071 ecode1 = SWIG_AsVal_int(obj0, &val1);
22072 if (!SWIG_IsOK(ecode1)) {
22073 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22074 }
22075 arg1 = static_cast< int >(val1);
22076 }
22077 {
22078 PyThreadState* __tstate = wxPyBeginAllowThreads();
22079 result = (int)wxDateTime::GetCentury(arg1);
22080 wxPyEndAllowThreads(__tstate);
22081 if (PyErr_Occurred()) SWIG_fail;
22082 }
22083 resultobj = SWIG_From_int(static_cast< int >(result));
22084 return resultobj;
22085 fail:
22086 return NULL;
22087 }
22088
22089
22090 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22091 PyObject *resultobj = 0;
22092 int arg1 ;
22093 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22094 int result;
22095 int val1 ;
22096 int ecode1 = 0 ;
22097 int val2 ;
22098 int ecode2 = 0 ;
22099 PyObject * obj0 = 0 ;
22100 PyObject * obj1 = 0 ;
22101 char * kwnames[] = {
22102 (char *) "year",(char *) "cal", NULL
22103 };
22104
22105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22106 ecode1 = SWIG_AsVal_int(obj0, &val1);
22107 if (!SWIG_IsOK(ecode1)) {
22108 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22109 }
22110 arg1 = static_cast< int >(val1);
22111 if (obj1) {
22112 ecode2 = SWIG_AsVal_int(obj1, &val2);
22113 if (!SWIG_IsOK(ecode2)) {
22114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22115 }
22116 arg2 = static_cast< wxDateTime::Calendar >(val2);
22117 }
22118 {
22119 PyThreadState* __tstate = wxPyBeginAllowThreads();
22120 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22121 wxPyEndAllowThreads(__tstate);
22122 if (PyErr_Occurred()) SWIG_fail;
22123 }
22124 resultobj = SWIG_From_int(static_cast< int >(result));
22125 return resultobj;
22126 fail:
22127 return NULL;
22128 }
22129
22130
22131 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22132 PyObject *resultobj = 0;
22133 wxDateTime::Month arg1 ;
22134 int arg2 = (int) wxDateTime::Inv_Year ;
22135 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22136 int result;
22137 int val1 ;
22138 int ecode1 = 0 ;
22139 int val2 ;
22140 int ecode2 = 0 ;
22141 int val3 ;
22142 int ecode3 = 0 ;
22143 PyObject * obj0 = 0 ;
22144 PyObject * obj1 = 0 ;
22145 PyObject * obj2 = 0 ;
22146 char * kwnames[] = {
22147 (char *) "month",(char *) "year",(char *) "cal", NULL
22148 };
22149
22150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22151 ecode1 = SWIG_AsVal_int(obj0, &val1);
22152 if (!SWIG_IsOK(ecode1)) {
22153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22154 }
22155 arg1 = static_cast< wxDateTime::Month >(val1);
22156 if (obj1) {
22157 ecode2 = SWIG_AsVal_int(obj1, &val2);
22158 if (!SWIG_IsOK(ecode2)) {
22159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22160 }
22161 arg2 = static_cast< int >(val2);
22162 }
22163 if (obj2) {
22164 ecode3 = SWIG_AsVal_int(obj2, &val3);
22165 if (!SWIG_IsOK(ecode3)) {
22166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22167 }
22168 arg3 = static_cast< wxDateTime::Calendar >(val3);
22169 }
22170 {
22171 PyThreadState* __tstate = wxPyBeginAllowThreads();
22172 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22173 wxPyEndAllowThreads(__tstate);
22174 if (PyErr_Occurred()) SWIG_fail;
22175 }
22176 resultobj = SWIG_From_int(static_cast< int >(result));
22177 return resultobj;
22178 fail:
22179 return NULL;
22180 }
22181
22182
22183 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22184 PyObject *resultobj = 0;
22185 wxDateTime::Month arg1 ;
22186 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22187 wxString result;
22188 int val1 ;
22189 int ecode1 = 0 ;
22190 int val2 ;
22191 int ecode2 = 0 ;
22192 PyObject * obj0 = 0 ;
22193 PyObject * obj1 = 0 ;
22194 char * kwnames[] = {
22195 (char *) "month",(char *) "flags", NULL
22196 };
22197
22198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22199 ecode1 = SWIG_AsVal_int(obj0, &val1);
22200 if (!SWIG_IsOK(ecode1)) {
22201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22202 }
22203 arg1 = static_cast< wxDateTime::Month >(val1);
22204 if (obj1) {
22205 ecode2 = SWIG_AsVal_int(obj1, &val2);
22206 if (!SWIG_IsOK(ecode2)) {
22207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22208 }
22209 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22210 }
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 result = wxDateTime::GetMonthName(arg1,arg2);
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 {
22218 #if wxUSE_UNICODE
22219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22220 #else
22221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22222 #endif
22223 }
22224 return resultobj;
22225 fail:
22226 return NULL;
22227 }
22228
22229
22230 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22231 PyObject *resultobj = 0;
22232 wxDateTime::WeekDay arg1 ;
22233 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22234 wxString result;
22235 int val1 ;
22236 int ecode1 = 0 ;
22237 int val2 ;
22238 int ecode2 = 0 ;
22239 PyObject * obj0 = 0 ;
22240 PyObject * obj1 = 0 ;
22241 char * kwnames[] = {
22242 (char *) "weekday",(char *) "flags", NULL
22243 };
22244
22245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22246 ecode1 = SWIG_AsVal_int(obj0, &val1);
22247 if (!SWIG_IsOK(ecode1)) {
22248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22249 }
22250 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22251 if (obj1) {
22252 ecode2 = SWIG_AsVal_int(obj1, &val2);
22253 if (!SWIG_IsOK(ecode2)) {
22254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22255 }
22256 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22257 }
22258 {
22259 PyThreadState* __tstate = wxPyBeginAllowThreads();
22260 result = wxDateTime::GetWeekDayName(arg1,arg2);
22261 wxPyEndAllowThreads(__tstate);
22262 if (PyErr_Occurred()) SWIG_fail;
22263 }
22264 {
22265 #if wxUSE_UNICODE
22266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22267 #else
22268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22269 #endif
22270 }
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22278 PyObject *resultobj = 0;
22279 PyObject *result = 0 ;
22280
22281 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22282 {
22283 PyThreadState* __tstate = wxPyBeginAllowThreads();
22284 result = (PyObject *)wxDateTime_GetAmPmStrings();
22285 wxPyEndAllowThreads(__tstate);
22286 if (PyErr_Occurred()) SWIG_fail;
22287 }
22288 resultobj = result;
22289 return resultobj;
22290 fail:
22291 return NULL;
22292 }
22293
22294
22295 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22296 PyObject *resultobj = 0;
22297 int arg1 = (int) wxDateTime::Inv_Year ;
22298 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22299 bool result;
22300 int val1 ;
22301 int ecode1 = 0 ;
22302 int val2 ;
22303 int ecode2 = 0 ;
22304 PyObject * obj0 = 0 ;
22305 PyObject * obj1 = 0 ;
22306 char * kwnames[] = {
22307 (char *) "year",(char *) "country", NULL
22308 };
22309
22310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22311 if (obj0) {
22312 ecode1 = SWIG_AsVal_int(obj0, &val1);
22313 if (!SWIG_IsOK(ecode1)) {
22314 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22315 }
22316 arg1 = static_cast< int >(val1);
22317 }
22318 if (obj1) {
22319 ecode2 = SWIG_AsVal_int(obj1, &val2);
22320 if (!SWIG_IsOK(ecode2)) {
22321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22322 }
22323 arg2 = static_cast< wxDateTime::Country >(val2);
22324 }
22325 {
22326 PyThreadState* __tstate = wxPyBeginAllowThreads();
22327 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 {
22332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22333 }
22334 return resultobj;
22335 fail:
22336 return NULL;
22337 }
22338
22339
22340 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22341 PyObject *resultobj = 0;
22342 int arg1 = (int) wxDateTime::Inv_Year ;
22343 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22344 wxDateTime result;
22345 int val1 ;
22346 int ecode1 = 0 ;
22347 int val2 ;
22348 int ecode2 = 0 ;
22349 PyObject * obj0 = 0 ;
22350 PyObject * obj1 = 0 ;
22351 char * kwnames[] = {
22352 (char *) "year",(char *) "country", NULL
22353 };
22354
22355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22356 if (obj0) {
22357 ecode1 = SWIG_AsVal_int(obj0, &val1);
22358 if (!SWIG_IsOK(ecode1)) {
22359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22360 }
22361 arg1 = static_cast< int >(val1);
22362 }
22363 if (obj1) {
22364 ecode2 = SWIG_AsVal_int(obj1, &val2);
22365 if (!SWIG_IsOK(ecode2)) {
22366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22367 }
22368 arg2 = static_cast< wxDateTime::Country >(val2);
22369 }
22370 {
22371 PyThreadState* __tstate = wxPyBeginAllowThreads();
22372 result = wxDateTime::GetBeginDST(arg1,arg2);
22373 wxPyEndAllowThreads(__tstate);
22374 if (PyErr_Occurred()) SWIG_fail;
22375 }
22376 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22377 return resultobj;
22378 fail:
22379 return NULL;
22380 }
22381
22382
22383 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22384 PyObject *resultobj = 0;
22385 int arg1 = (int) wxDateTime::Inv_Year ;
22386 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22387 wxDateTime result;
22388 int val1 ;
22389 int ecode1 = 0 ;
22390 int val2 ;
22391 int ecode2 = 0 ;
22392 PyObject * obj0 = 0 ;
22393 PyObject * obj1 = 0 ;
22394 char * kwnames[] = {
22395 (char *) "year",(char *) "country", NULL
22396 };
22397
22398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22399 if (obj0) {
22400 ecode1 = SWIG_AsVal_int(obj0, &val1);
22401 if (!SWIG_IsOK(ecode1)) {
22402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22403 }
22404 arg1 = static_cast< int >(val1);
22405 }
22406 if (obj1) {
22407 ecode2 = SWIG_AsVal_int(obj1, &val2);
22408 if (!SWIG_IsOK(ecode2)) {
22409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22410 }
22411 arg2 = static_cast< wxDateTime::Country >(val2);
22412 }
22413 {
22414 PyThreadState* __tstate = wxPyBeginAllowThreads();
22415 result = wxDateTime::GetEndDST(arg1,arg2);
22416 wxPyEndAllowThreads(__tstate);
22417 if (PyErr_Occurred()) SWIG_fail;
22418 }
22419 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22420 return resultobj;
22421 fail:
22422 return NULL;
22423 }
22424
22425
22426 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22427 PyObject *resultobj = 0;
22428 wxDateTime result;
22429
22430 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22431 {
22432 PyThreadState* __tstate = wxPyBeginAllowThreads();
22433 result = wxDateTime::Now();
22434 wxPyEndAllowThreads(__tstate);
22435 if (PyErr_Occurred()) SWIG_fail;
22436 }
22437 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22438 return resultobj;
22439 fail:
22440 return NULL;
22441 }
22442
22443
22444 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22445 PyObject *resultobj = 0;
22446 wxDateTime result;
22447
22448 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22449 {
22450 PyThreadState* __tstate = wxPyBeginAllowThreads();
22451 result = wxDateTime::UNow();
22452 wxPyEndAllowThreads(__tstate);
22453 if (PyErr_Occurred()) SWIG_fail;
22454 }
22455 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22456 return resultobj;
22457 fail:
22458 return NULL;
22459 }
22460
22461
22462 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22463 PyObject *resultobj = 0;
22464 wxDateTime result;
22465
22466 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22467 {
22468 PyThreadState* __tstate = wxPyBeginAllowThreads();
22469 result = wxDateTime::Today();
22470 wxPyEndAllowThreads(__tstate);
22471 if (PyErr_Occurred()) SWIG_fail;
22472 }
22473 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22474 return resultobj;
22475 fail:
22476 return NULL;
22477 }
22478
22479
22480 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22481 PyObject *resultobj = 0;
22482 wxDateTime *result = 0 ;
22483
22484 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22485 {
22486 PyThreadState* __tstate = wxPyBeginAllowThreads();
22487 result = (wxDateTime *)new wxDateTime();
22488 wxPyEndAllowThreads(__tstate);
22489 if (PyErr_Occurred()) SWIG_fail;
22490 }
22491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22499 PyObject *resultobj = 0;
22500 time_t arg1 ;
22501 wxDateTime *result = 0 ;
22502 unsigned int val1 ;
22503 int ecode1 = 0 ;
22504 PyObject * obj0 = 0 ;
22505 char * kwnames[] = {
22506 (char *) "timet", NULL
22507 };
22508
22509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22510 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22511 if (!SWIG_IsOK(ecode1)) {
22512 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22513 }
22514 arg1 = static_cast< time_t >(val1);
22515 {
22516 PyThreadState* __tstate = wxPyBeginAllowThreads();
22517 result = (wxDateTime *)new wxDateTime(arg1);
22518 wxPyEndAllowThreads(__tstate);
22519 if (PyErr_Occurred()) SWIG_fail;
22520 }
22521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22522 return resultobj;
22523 fail:
22524 return NULL;
22525 }
22526
22527
22528 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22529 PyObject *resultobj = 0;
22530 double arg1 ;
22531 wxDateTime *result = 0 ;
22532 double val1 ;
22533 int ecode1 = 0 ;
22534 PyObject * obj0 = 0 ;
22535 char * kwnames[] = {
22536 (char *) "jdn", NULL
22537 };
22538
22539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22540 ecode1 = SWIG_AsVal_double(obj0, &val1);
22541 if (!SWIG_IsOK(ecode1)) {
22542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22543 }
22544 arg1 = static_cast< double >(val1);
22545 {
22546 PyThreadState* __tstate = wxPyBeginAllowThreads();
22547 result = (wxDateTime *)new wxDateTime(arg1);
22548 wxPyEndAllowThreads(__tstate);
22549 if (PyErr_Occurred()) SWIG_fail;
22550 }
22551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22552 return resultobj;
22553 fail:
22554 return NULL;
22555 }
22556
22557
22558 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22559 PyObject *resultobj = 0;
22560 int arg1 ;
22561 int arg2 = (int) 0 ;
22562 int arg3 = (int) 0 ;
22563 int arg4 = (int) 0 ;
22564 wxDateTime *result = 0 ;
22565 int val1 ;
22566 int ecode1 = 0 ;
22567 int val2 ;
22568 int ecode2 = 0 ;
22569 int val3 ;
22570 int ecode3 = 0 ;
22571 int val4 ;
22572 int ecode4 = 0 ;
22573 PyObject * obj0 = 0 ;
22574 PyObject * obj1 = 0 ;
22575 PyObject * obj2 = 0 ;
22576 PyObject * obj3 = 0 ;
22577 char * kwnames[] = {
22578 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22579 };
22580
22581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22582 ecode1 = SWIG_AsVal_int(obj0, &val1);
22583 if (!SWIG_IsOK(ecode1)) {
22584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22585 }
22586 arg1 = static_cast< int >(val1);
22587 if (obj1) {
22588 ecode2 = SWIG_AsVal_int(obj1, &val2);
22589 if (!SWIG_IsOK(ecode2)) {
22590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22591 }
22592 arg2 = static_cast< int >(val2);
22593 }
22594 if (obj2) {
22595 ecode3 = SWIG_AsVal_int(obj2, &val3);
22596 if (!SWIG_IsOK(ecode3)) {
22597 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22598 }
22599 arg3 = static_cast< int >(val3);
22600 }
22601 if (obj3) {
22602 ecode4 = SWIG_AsVal_int(obj3, &val4);
22603 if (!SWIG_IsOK(ecode4)) {
22604 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22605 }
22606 arg4 = static_cast< int >(val4);
22607 }
22608 {
22609 PyThreadState* __tstate = wxPyBeginAllowThreads();
22610 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22611 wxPyEndAllowThreads(__tstate);
22612 if (PyErr_Occurred()) SWIG_fail;
22613 }
22614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22615 return resultobj;
22616 fail:
22617 return NULL;
22618 }
22619
22620
22621 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22622 PyObject *resultobj = 0;
22623 int arg1 ;
22624 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22625 int arg3 = (int) wxDateTime::Inv_Year ;
22626 int arg4 = (int) 0 ;
22627 int arg5 = (int) 0 ;
22628 int arg6 = (int) 0 ;
22629 int arg7 = (int) 0 ;
22630 wxDateTime *result = 0 ;
22631 int val1 ;
22632 int ecode1 = 0 ;
22633 int val2 ;
22634 int ecode2 = 0 ;
22635 int val3 ;
22636 int ecode3 = 0 ;
22637 int val4 ;
22638 int ecode4 = 0 ;
22639 int val5 ;
22640 int ecode5 = 0 ;
22641 int val6 ;
22642 int ecode6 = 0 ;
22643 int val7 ;
22644 int ecode7 = 0 ;
22645 PyObject * obj0 = 0 ;
22646 PyObject * obj1 = 0 ;
22647 PyObject * obj2 = 0 ;
22648 PyObject * obj3 = 0 ;
22649 PyObject * obj4 = 0 ;
22650 PyObject * obj5 = 0 ;
22651 PyObject * obj6 = 0 ;
22652 char * kwnames[] = {
22653 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22654 };
22655
22656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22657 ecode1 = SWIG_AsVal_int(obj0, &val1);
22658 if (!SWIG_IsOK(ecode1)) {
22659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22660 }
22661 arg1 = static_cast< int >(val1);
22662 if (obj1) {
22663 ecode2 = SWIG_AsVal_int(obj1, &val2);
22664 if (!SWIG_IsOK(ecode2)) {
22665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22666 }
22667 arg2 = static_cast< wxDateTime::Month >(val2);
22668 }
22669 if (obj2) {
22670 ecode3 = SWIG_AsVal_int(obj2, &val3);
22671 if (!SWIG_IsOK(ecode3)) {
22672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22673 }
22674 arg3 = static_cast< int >(val3);
22675 }
22676 if (obj3) {
22677 ecode4 = SWIG_AsVal_int(obj3, &val4);
22678 if (!SWIG_IsOK(ecode4)) {
22679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22680 }
22681 arg4 = static_cast< int >(val4);
22682 }
22683 if (obj4) {
22684 ecode5 = SWIG_AsVal_int(obj4, &val5);
22685 if (!SWIG_IsOK(ecode5)) {
22686 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22687 }
22688 arg5 = static_cast< int >(val5);
22689 }
22690 if (obj5) {
22691 ecode6 = SWIG_AsVal_int(obj5, &val6);
22692 if (!SWIG_IsOK(ecode6)) {
22693 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22694 }
22695 arg6 = static_cast< int >(val6);
22696 }
22697 if (obj6) {
22698 ecode7 = SWIG_AsVal_int(obj6, &val7);
22699 if (!SWIG_IsOK(ecode7)) {
22700 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22701 }
22702 arg7 = static_cast< int >(val7);
22703 }
22704 {
22705 PyThreadState* __tstate = wxPyBeginAllowThreads();
22706 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22707 wxPyEndAllowThreads(__tstate);
22708 if (PyErr_Occurred()) SWIG_fail;
22709 }
22710 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22711 return resultobj;
22712 fail:
22713 return NULL;
22714 }
22715
22716
22717 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22718 PyObject *resultobj = 0;
22719 wxDateTime *arg1 = 0 ;
22720 wxDateTime *result = 0 ;
22721 void *argp1 = 0 ;
22722 int res1 = 0 ;
22723 PyObject * obj0 = 0 ;
22724 char * kwnames[] = {
22725 (char *) "date", NULL
22726 };
22727
22728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22729 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22730 if (!SWIG_IsOK(res1)) {
22731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22732 }
22733 if (!argp1) {
22734 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22735 }
22736 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22737 {
22738 PyThreadState* __tstate = wxPyBeginAllowThreads();
22739 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22744 return resultobj;
22745 fail:
22746 return NULL;
22747 }
22748
22749
22750 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22751 PyObject *resultobj = 0;
22752 wxDateTime *arg1 = (wxDateTime *) 0 ;
22753 void *argp1 = 0 ;
22754 int res1 = 0 ;
22755 PyObject *swig_obj[1] ;
22756
22757 if (!args) SWIG_fail;
22758 swig_obj[0] = args;
22759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22760 if (!SWIG_IsOK(res1)) {
22761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22762 }
22763 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22764 {
22765 PyThreadState* __tstate = wxPyBeginAllowThreads();
22766 delete arg1;
22767
22768 wxPyEndAllowThreads(__tstate);
22769 if (PyErr_Occurred()) SWIG_fail;
22770 }
22771 resultobj = SWIG_Py_Void();
22772 return resultobj;
22773 fail:
22774 return NULL;
22775 }
22776
22777
22778 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22779 PyObject *resultobj = 0;
22780 wxDateTime *arg1 = (wxDateTime *) 0 ;
22781 wxDateTime *result = 0 ;
22782 void *argp1 = 0 ;
22783 int res1 = 0 ;
22784 PyObject *swig_obj[1] ;
22785
22786 if (!args) SWIG_fail;
22787 swig_obj[0] = args;
22788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22789 if (!SWIG_IsOK(res1)) {
22790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22791 }
22792 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22793 {
22794 PyThreadState* __tstate = wxPyBeginAllowThreads();
22795 {
22796 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22797 result = (wxDateTime *) &_result_ref;
22798 }
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22810 PyObject *resultobj = 0;
22811 wxDateTime *arg1 = (wxDateTime *) 0 ;
22812 time_t arg2 ;
22813 wxDateTime *result = 0 ;
22814 void *argp1 = 0 ;
22815 int res1 = 0 ;
22816 unsigned int val2 ;
22817 int ecode2 = 0 ;
22818 PyObject * obj0 = 0 ;
22819 PyObject * obj1 = 0 ;
22820 char * kwnames[] = {
22821 (char *) "self",(char *) "timet", NULL
22822 };
22823
22824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22826 if (!SWIG_IsOK(res1)) {
22827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22828 }
22829 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22830 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22831 if (!SWIG_IsOK(ecode2)) {
22832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22833 }
22834 arg2 = static_cast< time_t >(val2);
22835 {
22836 PyThreadState* __tstate = wxPyBeginAllowThreads();
22837 {
22838 wxDateTime &_result_ref = (arg1)->Set(arg2);
22839 result = (wxDateTime *) &_result_ref;
22840 }
22841 wxPyEndAllowThreads(__tstate);
22842 if (PyErr_Occurred()) SWIG_fail;
22843 }
22844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22845 return resultobj;
22846 fail:
22847 return NULL;
22848 }
22849
22850
22851 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22852 PyObject *resultobj = 0;
22853 wxDateTime *arg1 = (wxDateTime *) 0 ;
22854 double arg2 ;
22855 wxDateTime *result = 0 ;
22856 void *argp1 = 0 ;
22857 int res1 = 0 ;
22858 double val2 ;
22859 int ecode2 = 0 ;
22860 PyObject * obj0 = 0 ;
22861 PyObject * obj1 = 0 ;
22862 char * kwnames[] = {
22863 (char *) "self",(char *) "jdn", NULL
22864 };
22865
22866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22868 if (!SWIG_IsOK(res1)) {
22869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22870 }
22871 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22872 ecode2 = SWIG_AsVal_double(obj1, &val2);
22873 if (!SWIG_IsOK(ecode2)) {
22874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22875 }
22876 arg2 = static_cast< double >(val2);
22877 {
22878 PyThreadState* __tstate = wxPyBeginAllowThreads();
22879 {
22880 wxDateTime &_result_ref = (arg1)->Set(arg2);
22881 result = (wxDateTime *) &_result_ref;
22882 }
22883 wxPyEndAllowThreads(__tstate);
22884 if (PyErr_Occurred()) SWIG_fail;
22885 }
22886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22887 return resultobj;
22888 fail:
22889 return NULL;
22890 }
22891
22892
22893 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22894 PyObject *resultobj = 0;
22895 wxDateTime *arg1 = (wxDateTime *) 0 ;
22896 int arg2 ;
22897 int arg3 = (int) 0 ;
22898 int arg4 = (int) 0 ;
22899 int arg5 = (int) 0 ;
22900 wxDateTime *result = 0 ;
22901 void *argp1 = 0 ;
22902 int res1 = 0 ;
22903 int val2 ;
22904 int ecode2 = 0 ;
22905 int val3 ;
22906 int ecode3 = 0 ;
22907 int val4 ;
22908 int ecode4 = 0 ;
22909 int val5 ;
22910 int ecode5 = 0 ;
22911 PyObject * obj0 = 0 ;
22912 PyObject * obj1 = 0 ;
22913 PyObject * obj2 = 0 ;
22914 PyObject * obj3 = 0 ;
22915 PyObject * obj4 = 0 ;
22916 char * kwnames[] = {
22917 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22918 };
22919
22920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22922 if (!SWIG_IsOK(res1)) {
22923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22924 }
22925 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22926 ecode2 = SWIG_AsVal_int(obj1, &val2);
22927 if (!SWIG_IsOK(ecode2)) {
22928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22929 }
22930 arg2 = static_cast< int >(val2);
22931 if (obj2) {
22932 ecode3 = SWIG_AsVal_int(obj2, &val3);
22933 if (!SWIG_IsOK(ecode3)) {
22934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22935 }
22936 arg3 = static_cast< int >(val3);
22937 }
22938 if (obj3) {
22939 ecode4 = SWIG_AsVal_int(obj3, &val4);
22940 if (!SWIG_IsOK(ecode4)) {
22941 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22942 }
22943 arg4 = static_cast< int >(val4);
22944 }
22945 if (obj4) {
22946 ecode5 = SWIG_AsVal_int(obj4, &val5);
22947 if (!SWIG_IsOK(ecode5)) {
22948 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22949 }
22950 arg5 = static_cast< int >(val5);
22951 }
22952 {
22953 PyThreadState* __tstate = wxPyBeginAllowThreads();
22954 {
22955 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22956 result = (wxDateTime *) &_result_ref;
22957 }
22958 wxPyEndAllowThreads(__tstate);
22959 if (PyErr_Occurred()) SWIG_fail;
22960 }
22961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj = 0;
22970 wxDateTime *arg1 = (wxDateTime *) 0 ;
22971 int arg2 ;
22972 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22973 int arg4 = (int) wxDateTime::Inv_Year ;
22974 int arg5 = (int) 0 ;
22975 int arg6 = (int) 0 ;
22976 int arg7 = (int) 0 ;
22977 int arg8 = (int) 0 ;
22978 wxDateTime *result = 0 ;
22979 void *argp1 = 0 ;
22980 int res1 = 0 ;
22981 int val2 ;
22982 int ecode2 = 0 ;
22983 int val3 ;
22984 int ecode3 = 0 ;
22985 int val4 ;
22986 int ecode4 = 0 ;
22987 int val5 ;
22988 int ecode5 = 0 ;
22989 int val6 ;
22990 int ecode6 = 0 ;
22991 int val7 ;
22992 int ecode7 = 0 ;
22993 int val8 ;
22994 int ecode8 = 0 ;
22995 PyObject * obj0 = 0 ;
22996 PyObject * obj1 = 0 ;
22997 PyObject * obj2 = 0 ;
22998 PyObject * obj3 = 0 ;
22999 PyObject * obj4 = 0 ;
23000 PyObject * obj5 = 0 ;
23001 PyObject * obj6 = 0 ;
23002 PyObject * obj7 = 0 ;
23003 char * kwnames[] = {
23004 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23005 };
23006
23007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23009 if (!SWIG_IsOK(res1)) {
23010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23011 }
23012 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23013 ecode2 = SWIG_AsVal_int(obj1, &val2);
23014 if (!SWIG_IsOK(ecode2)) {
23015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23016 }
23017 arg2 = static_cast< int >(val2);
23018 if (obj2) {
23019 ecode3 = SWIG_AsVal_int(obj2, &val3);
23020 if (!SWIG_IsOK(ecode3)) {
23021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23022 }
23023 arg3 = static_cast< wxDateTime::Month >(val3);
23024 }
23025 if (obj3) {
23026 ecode4 = SWIG_AsVal_int(obj3, &val4);
23027 if (!SWIG_IsOK(ecode4)) {
23028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23029 }
23030 arg4 = static_cast< int >(val4);
23031 }
23032 if (obj4) {
23033 ecode5 = SWIG_AsVal_int(obj4, &val5);
23034 if (!SWIG_IsOK(ecode5)) {
23035 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23036 }
23037 arg5 = static_cast< int >(val5);
23038 }
23039 if (obj5) {
23040 ecode6 = SWIG_AsVal_int(obj5, &val6);
23041 if (!SWIG_IsOK(ecode6)) {
23042 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23043 }
23044 arg6 = static_cast< int >(val6);
23045 }
23046 if (obj6) {
23047 ecode7 = SWIG_AsVal_int(obj6, &val7);
23048 if (!SWIG_IsOK(ecode7)) {
23049 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23050 }
23051 arg7 = static_cast< int >(val7);
23052 }
23053 if (obj7) {
23054 ecode8 = SWIG_AsVal_int(obj7, &val8);
23055 if (!SWIG_IsOK(ecode8)) {
23056 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23057 }
23058 arg8 = static_cast< int >(val8);
23059 }
23060 {
23061 PyThreadState* __tstate = wxPyBeginAllowThreads();
23062 {
23063 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23064 result = (wxDateTime *) &_result_ref;
23065 }
23066 wxPyEndAllowThreads(__tstate);
23067 if (PyErr_Occurred()) SWIG_fail;
23068 }
23069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23070 return resultobj;
23071 fail:
23072 return NULL;
23073 }
23074
23075
23076 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23077 PyObject *resultobj = 0;
23078 wxDateTime *arg1 = (wxDateTime *) 0 ;
23079 wxDateTime *result = 0 ;
23080 void *argp1 = 0 ;
23081 int res1 = 0 ;
23082 PyObject *swig_obj[1] ;
23083
23084 if (!args) SWIG_fail;
23085 swig_obj[0] = args;
23086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23087 if (!SWIG_IsOK(res1)) {
23088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23089 }
23090 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23091 {
23092 PyThreadState* __tstate = wxPyBeginAllowThreads();
23093 {
23094 wxDateTime &_result_ref = (arg1)->ResetTime();
23095 result = (wxDateTime *) &_result_ref;
23096 }
23097 wxPyEndAllowThreads(__tstate);
23098 if (PyErr_Occurred()) SWIG_fail;
23099 }
23100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23101 return resultobj;
23102 fail:
23103 return NULL;
23104 }
23105
23106
23107 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23108 PyObject *resultobj = 0;
23109 wxDateTime *arg1 = (wxDateTime *) 0 ;
23110 int arg2 ;
23111 wxDateTime *result = 0 ;
23112 void *argp1 = 0 ;
23113 int res1 = 0 ;
23114 int val2 ;
23115 int ecode2 = 0 ;
23116 PyObject * obj0 = 0 ;
23117 PyObject * obj1 = 0 ;
23118 char * kwnames[] = {
23119 (char *) "self",(char *) "year", NULL
23120 };
23121
23122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23124 if (!SWIG_IsOK(res1)) {
23125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23126 }
23127 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23128 ecode2 = SWIG_AsVal_int(obj1, &val2);
23129 if (!SWIG_IsOK(ecode2)) {
23130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23131 }
23132 arg2 = static_cast< int >(val2);
23133 {
23134 PyThreadState* __tstate = wxPyBeginAllowThreads();
23135 {
23136 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23137 result = (wxDateTime *) &_result_ref;
23138 }
23139 wxPyEndAllowThreads(__tstate);
23140 if (PyErr_Occurred()) SWIG_fail;
23141 }
23142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23143 return resultobj;
23144 fail:
23145 return NULL;
23146 }
23147
23148
23149 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23150 PyObject *resultobj = 0;
23151 wxDateTime *arg1 = (wxDateTime *) 0 ;
23152 wxDateTime::Month arg2 ;
23153 wxDateTime *result = 0 ;
23154 void *argp1 = 0 ;
23155 int res1 = 0 ;
23156 int val2 ;
23157 int ecode2 = 0 ;
23158 PyObject * obj0 = 0 ;
23159 PyObject * obj1 = 0 ;
23160 char * kwnames[] = {
23161 (char *) "self",(char *) "month", NULL
23162 };
23163
23164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23166 if (!SWIG_IsOK(res1)) {
23167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23168 }
23169 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23170 ecode2 = SWIG_AsVal_int(obj1, &val2);
23171 if (!SWIG_IsOK(ecode2)) {
23172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23173 }
23174 arg2 = static_cast< wxDateTime::Month >(val2);
23175 {
23176 PyThreadState* __tstate = wxPyBeginAllowThreads();
23177 {
23178 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23179 result = (wxDateTime *) &_result_ref;
23180 }
23181 wxPyEndAllowThreads(__tstate);
23182 if (PyErr_Occurred()) SWIG_fail;
23183 }
23184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23185 return resultobj;
23186 fail:
23187 return NULL;
23188 }
23189
23190
23191 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23192 PyObject *resultobj = 0;
23193 wxDateTime *arg1 = (wxDateTime *) 0 ;
23194 int arg2 ;
23195 wxDateTime *result = 0 ;
23196 void *argp1 = 0 ;
23197 int res1 = 0 ;
23198 int val2 ;
23199 int ecode2 = 0 ;
23200 PyObject * obj0 = 0 ;
23201 PyObject * obj1 = 0 ;
23202 char * kwnames[] = {
23203 (char *) "self",(char *) "day", NULL
23204 };
23205
23206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23208 if (!SWIG_IsOK(res1)) {
23209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23210 }
23211 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23212 ecode2 = SWIG_AsVal_int(obj1, &val2);
23213 if (!SWIG_IsOK(ecode2)) {
23214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23215 }
23216 arg2 = static_cast< int >(val2);
23217 {
23218 PyThreadState* __tstate = wxPyBeginAllowThreads();
23219 {
23220 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23221 result = (wxDateTime *) &_result_ref;
23222 }
23223 wxPyEndAllowThreads(__tstate);
23224 if (PyErr_Occurred()) SWIG_fail;
23225 }
23226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23227 return resultobj;
23228 fail:
23229 return NULL;
23230 }
23231
23232
23233 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23234 PyObject *resultobj = 0;
23235 wxDateTime *arg1 = (wxDateTime *) 0 ;
23236 int arg2 ;
23237 wxDateTime *result = 0 ;
23238 void *argp1 = 0 ;
23239 int res1 = 0 ;
23240 int val2 ;
23241 int ecode2 = 0 ;
23242 PyObject * obj0 = 0 ;
23243 PyObject * obj1 = 0 ;
23244 char * kwnames[] = {
23245 (char *) "self",(char *) "hour", NULL
23246 };
23247
23248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23250 if (!SWIG_IsOK(res1)) {
23251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23252 }
23253 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23254 ecode2 = SWIG_AsVal_int(obj1, &val2);
23255 if (!SWIG_IsOK(ecode2)) {
23256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23257 }
23258 arg2 = static_cast< int >(val2);
23259 {
23260 PyThreadState* __tstate = wxPyBeginAllowThreads();
23261 {
23262 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23263 result = (wxDateTime *) &_result_ref;
23264 }
23265 wxPyEndAllowThreads(__tstate);
23266 if (PyErr_Occurred()) SWIG_fail;
23267 }
23268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23269 return resultobj;
23270 fail:
23271 return NULL;
23272 }
23273
23274
23275 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23276 PyObject *resultobj = 0;
23277 wxDateTime *arg1 = (wxDateTime *) 0 ;
23278 int arg2 ;
23279 wxDateTime *result = 0 ;
23280 void *argp1 = 0 ;
23281 int res1 = 0 ;
23282 int val2 ;
23283 int ecode2 = 0 ;
23284 PyObject * obj0 = 0 ;
23285 PyObject * obj1 = 0 ;
23286 char * kwnames[] = {
23287 (char *) "self",(char *) "minute", NULL
23288 };
23289
23290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23292 if (!SWIG_IsOK(res1)) {
23293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23294 }
23295 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23296 ecode2 = SWIG_AsVal_int(obj1, &val2);
23297 if (!SWIG_IsOK(ecode2)) {
23298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23299 }
23300 arg2 = static_cast< int >(val2);
23301 {
23302 PyThreadState* __tstate = wxPyBeginAllowThreads();
23303 {
23304 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23305 result = (wxDateTime *) &_result_ref;
23306 }
23307 wxPyEndAllowThreads(__tstate);
23308 if (PyErr_Occurred()) SWIG_fail;
23309 }
23310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23311 return resultobj;
23312 fail:
23313 return NULL;
23314 }
23315
23316
23317 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23318 PyObject *resultobj = 0;
23319 wxDateTime *arg1 = (wxDateTime *) 0 ;
23320 int arg2 ;
23321 wxDateTime *result = 0 ;
23322 void *argp1 = 0 ;
23323 int res1 = 0 ;
23324 int val2 ;
23325 int ecode2 = 0 ;
23326 PyObject * obj0 = 0 ;
23327 PyObject * obj1 = 0 ;
23328 char * kwnames[] = {
23329 (char *) "self",(char *) "second", NULL
23330 };
23331
23332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23334 if (!SWIG_IsOK(res1)) {
23335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23336 }
23337 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23338 ecode2 = SWIG_AsVal_int(obj1, &val2);
23339 if (!SWIG_IsOK(ecode2)) {
23340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23341 }
23342 arg2 = static_cast< int >(val2);
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 {
23346 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23347 result = (wxDateTime *) &_result_ref;
23348 }
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj = 0;
23361 wxDateTime *arg1 = (wxDateTime *) 0 ;
23362 int arg2 ;
23363 wxDateTime *result = 0 ;
23364 void *argp1 = 0 ;
23365 int res1 = 0 ;
23366 int val2 ;
23367 int ecode2 = 0 ;
23368 PyObject * obj0 = 0 ;
23369 PyObject * obj1 = 0 ;
23370 char * kwnames[] = {
23371 (char *) "self",(char *) "millisecond", NULL
23372 };
23373
23374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23376 if (!SWIG_IsOK(res1)) {
23377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23378 }
23379 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23380 ecode2 = SWIG_AsVal_int(obj1, &val2);
23381 if (!SWIG_IsOK(ecode2)) {
23382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23383 }
23384 arg2 = static_cast< int >(val2);
23385 {
23386 PyThreadState* __tstate = wxPyBeginAllowThreads();
23387 {
23388 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23389 result = (wxDateTime *) &_result_ref;
23390 }
23391 wxPyEndAllowThreads(__tstate);
23392 if (PyErr_Occurred()) SWIG_fail;
23393 }
23394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23395 return resultobj;
23396 fail:
23397 return NULL;
23398 }
23399
23400
23401 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23402 PyObject *resultobj = 0;
23403 wxDateTime *arg1 = (wxDateTime *) 0 ;
23404 wxDateTime::WeekDay arg2 ;
23405 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23406 wxDateTime *result = 0 ;
23407 void *argp1 = 0 ;
23408 int res1 = 0 ;
23409 int val2 ;
23410 int ecode2 = 0 ;
23411 int val3 ;
23412 int ecode3 = 0 ;
23413 PyObject * obj0 = 0 ;
23414 PyObject * obj1 = 0 ;
23415 PyObject * obj2 = 0 ;
23416 char * kwnames[] = {
23417 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23418 };
23419
23420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23422 if (!SWIG_IsOK(res1)) {
23423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23424 }
23425 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23426 ecode2 = SWIG_AsVal_int(obj1, &val2);
23427 if (!SWIG_IsOK(ecode2)) {
23428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23429 }
23430 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23431 if (obj2) {
23432 ecode3 = SWIG_AsVal_int(obj2, &val3);
23433 if (!SWIG_IsOK(ecode3)) {
23434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23435 }
23436 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23437 }
23438 {
23439 PyThreadState* __tstate = wxPyBeginAllowThreads();
23440 {
23441 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23442 result = (wxDateTime *) &_result_ref;
23443 }
23444 wxPyEndAllowThreads(__tstate);
23445 if (PyErr_Occurred()) SWIG_fail;
23446 }
23447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23448 return resultobj;
23449 fail:
23450 return NULL;
23451 }
23452
23453
23454 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23455 PyObject *resultobj = 0;
23456 wxDateTime *arg1 = (wxDateTime *) 0 ;
23457 wxDateTime::WeekDay arg2 ;
23458 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23459 wxDateTime result;
23460 void *argp1 = 0 ;
23461 int res1 = 0 ;
23462 int val2 ;
23463 int ecode2 = 0 ;
23464 int val3 ;
23465 int ecode3 = 0 ;
23466 PyObject * obj0 = 0 ;
23467 PyObject * obj1 = 0 ;
23468 PyObject * obj2 = 0 ;
23469 char * kwnames[] = {
23470 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23471 };
23472
23473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23475 if (!SWIG_IsOK(res1)) {
23476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23477 }
23478 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23479 ecode2 = SWIG_AsVal_int(obj1, &val2);
23480 if (!SWIG_IsOK(ecode2)) {
23481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23482 }
23483 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23484 if (obj2) {
23485 ecode3 = SWIG_AsVal_int(obj2, &val3);
23486 if (!SWIG_IsOK(ecode3)) {
23487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23488 }
23489 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23490 }
23491 {
23492 PyThreadState* __tstate = wxPyBeginAllowThreads();
23493 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23494 wxPyEndAllowThreads(__tstate);
23495 if (PyErr_Occurred()) SWIG_fail;
23496 }
23497 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23498 return resultobj;
23499 fail:
23500 return NULL;
23501 }
23502
23503
23504 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23505 PyObject *resultobj = 0;
23506 wxDateTime *arg1 = (wxDateTime *) 0 ;
23507 wxDateTime::WeekDay arg2 ;
23508 wxDateTime *result = 0 ;
23509 void *argp1 = 0 ;
23510 int res1 = 0 ;
23511 int val2 ;
23512 int ecode2 = 0 ;
23513 PyObject * obj0 = 0 ;
23514 PyObject * obj1 = 0 ;
23515 char * kwnames[] = {
23516 (char *) "self",(char *) "weekday", NULL
23517 };
23518
23519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23521 if (!SWIG_IsOK(res1)) {
23522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23523 }
23524 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23525 ecode2 = SWIG_AsVal_int(obj1, &val2);
23526 if (!SWIG_IsOK(ecode2)) {
23527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23528 }
23529 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23530 {
23531 PyThreadState* __tstate = wxPyBeginAllowThreads();
23532 {
23533 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23534 result = (wxDateTime *) &_result_ref;
23535 }
23536 wxPyEndAllowThreads(__tstate);
23537 if (PyErr_Occurred()) SWIG_fail;
23538 }
23539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23540 return resultobj;
23541 fail:
23542 return NULL;
23543 }
23544
23545
23546 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23547 PyObject *resultobj = 0;
23548 wxDateTime *arg1 = (wxDateTime *) 0 ;
23549 wxDateTime::WeekDay arg2 ;
23550 wxDateTime result;
23551 void *argp1 = 0 ;
23552 int res1 = 0 ;
23553 int val2 ;
23554 int ecode2 = 0 ;
23555 PyObject * obj0 = 0 ;
23556 PyObject * obj1 = 0 ;
23557 char * kwnames[] = {
23558 (char *) "self",(char *) "weekday", NULL
23559 };
23560
23561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23563 if (!SWIG_IsOK(res1)) {
23564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23565 }
23566 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23567 ecode2 = SWIG_AsVal_int(obj1, &val2);
23568 if (!SWIG_IsOK(ecode2)) {
23569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23570 }
23571 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (arg1)->GetNextWeekDay(arg2);
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23579 return resultobj;
23580 fail:
23581 return NULL;
23582 }
23583
23584
23585 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23586 PyObject *resultobj = 0;
23587 wxDateTime *arg1 = (wxDateTime *) 0 ;
23588 wxDateTime::WeekDay arg2 ;
23589 wxDateTime *result = 0 ;
23590 void *argp1 = 0 ;
23591 int res1 = 0 ;
23592 int val2 ;
23593 int ecode2 = 0 ;
23594 PyObject * obj0 = 0 ;
23595 PyObject * obj1 = 0 ;
23596 char * kwnames[] = {
23597 (char *) "self",(char *) "weekday", NULL
23598 };
23599
23600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23602 if (!SWIG_IsOK(res1)) {
23603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23604 }
23605 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23606 ecode2 = SWIG_AsVal_int(obj1, &val2);
23607 if (!SWIG_IsOK(ecode2)) {
23608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23609 }
23610 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23611 {
23612 PyThreadState* __tstate = wxPyBeginAllowThreads();
23613 {
23614 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23615 result = (wxDateTime *) &_result_ref;
23616 }
23617 wxPyEndAllowThreads(__tstate);
23618 if (PyErr_Occurred()) SWIG_fail;
23619 }
23620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23621 return resultobj;
23622 fail:
23623 return NULL;
23624 }
23625
23626
23627 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23628 PyObject *resultobj = 0;
23629 wxDateTime *arg1 = (wxDateTime *) 0 ;
23630 wxDateTime::WeekDay arg2 ;
23631 wxDateTime result;
23632 void *argp1 = 0 ;
23633 int res1 = 0 ;
23634 int val2 ;
23635 int ecode2 = 0 ;
23636 PyObject * obj0 = 0 ;
23637 PyObject * obj1 = 0 ;
23638 char * kwnames[] = {
23639 (char *) "self",(char *) "weekday", NULL
23640 };
23641
23642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23644 if (!SWIG_IsOK(res1)) {
23645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23646 }
23647 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23648 ecode2 = SWIG_AsVal_int(obj1, &val2);
23649 if (!SWIG_IsOK(ecode2)) {
23650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23651 }
23652 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23653 {
23654 PyThreadState* __tstate = wxPyBeginAllowThreads();
23655 result = (arg1)->GetPrevWeekDay(arg2);
23656 wxPyEndAllowThreads(__tstate);
23657 if (PyErr_Occurred()) SWIG_fail;
23658 }
23659 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23660 return resultobj;
23661 fail:
23662 return NULL;
23663 }
23664
23665
23666 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23667 PyObject *resultobj = 0;
23668 wxDateTime *arg1 = (wxDateTime *) 0 ;
23669 wxDateTime::WeekDay arg2 ;
23670 int arg3 = (int) 1 ;
23671 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23672 int arg5 = (int) wxDateTime::Inv_Year ;
23673 bool result;
23674 void *argp1 = 0 ;
23675 int res1 = 0 ;
23676 int val2 ;
23677 int ecode2 = 0 ;
23678 int val3 ;
23679 int ecode3 = 0 ;
23680 int val4 ;
23681 int ecode4 = 0 ;
23682 int val5 ;
23683 int ecode5 = 0 ;
23684 PyObject * obj0 = 0 ;
23685 PyObject * obj1 = 0 ;
23686 PyObject * obj2 = 0 ;
23687 PyObject * obj3 = 0 ;
23688 PyObject * obj4 = 0 ;
23689 char * kwnames[] = {
23690 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23691 };
23692
23693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23695 if (!SWIG_IsOK(res1)) {
23696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23697 }
23698 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23699 ecode2 = SWIG_AsVal_int(obj1, &val2);
23700 if (!SWIG_IsOK(ecode2)) {
23701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23702 }
23703 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23704 if (obj2) {
23705 ecode3 = SWIG_AsVal_int(obj2, &val3);
23706 if (!SWIG_IsOK(ecode3)) {
23707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23708 }
23709 arg3 = static_cast< int >(val3);
23710 }
23711 if (obj3) {
23712 ecode4 = SWIG_AsVal_int(obj3, &val4);
23713 if (!SWIG_IsOK(ecode4)) {
23714 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23715 }
23716 arg4 = static_cast< wxDateTime::Month >(val4);
23717 }
23718 if (obj4) {
23719 ecode5 = SWIG_AsVal_int(obj4, &val5);
23720 if (!SWIG_IsOK(ecode5)) {
23721 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23722 }
23723 arg5 = static_cast< int >(val5);
23724 }
23725 {
23726 PyThreadState* __tstate = wxPyBeginAllowThreads();
23727 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23728 wxPyEndAllowThreads(__tstate);
23729 if (PyErr_Occurred()) SWIG_fail;
23730 }
23731 {
23732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23733 }
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23741 PyObject *resultobj = 0;
23742 wxDateTime *arg1 = (wxDateTime *) 0 ;
23743 wxDateTime::WeekDay arg2 ;
23744 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23745 int arg4 = (int) wxDateTime::Inv_Year ;
23746 bool result;
23747 void *argp1 = 0 ;
23748 int res1 = 0 ;
23749 int val2 ;
23750 int ecode2 = 0 ;
23751 int val3 ;
23752 int ecode3 = 0 ;
23753 int val4 ;
23754 int ecode4 = 0 ;
23755 PyObject * obj0 = 0 ;
23756 PyObject * obj1 = 0 ;
23757 PyObject * obj2 = 0 ;
23758 PyObject * obj3 = 0 ;
23759 char * kwnames[] = {
23760 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23761 };
23762
23763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23765 if (!SWIG_IsOK(res1)) {
23766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23767 }
23768 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23769 ecode2 = SWIG_AsVal_int(obj1, &val2);
23770 if (!SWIG_IsOK(ecode2)) {
23771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23772 }
23773 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23774 if (obj2) {
23775 ecode3 = SWIG_AsVal_int(obj2, &val3);
23776 if (!SWIG_IsOK(ecode3)) {
23777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23778 }
23779 arg3 = static_cast< wxDateTime::Month >(val3);
23780 }
23781 if (obj3) {
23782 ecode4 = SWIG_AsVal_int(obj3, &val4);
23783 if (!SWIG_IsOK(ecode4)) {
23784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23785 }
23786 arg4 = static_cast< int >(val4);
23787 }
23788 {
23789 PyThreadState* __tstate = wxPyBeginAllowThreads();
23790 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23791 wxPyEndAllowThreads(__tstate);
23792 if (PyErr_Occurred()) SWIG_fail;
23793 }
23794 {
23795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23796 }
23797 return resultobj;
23798 fail:
23799 return NULL;
23800 }
23801
23802
23803 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23804 PyObject *resultobj = 0;
23805 wxDateTime *arg1 = (wxDateTime *) 0 ;
23806 wxDateTime::WeekDay arg2 ;
23807 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23808 int arg4 = (int) wxDateTime::Inv_Year ;
23809 wxDateTime result;
23810 void *argp1 = 0 ;
23811 int res1 = 0 ;
23812 int val2 ;
23813 int ecode2 = 0 ;
23814 int val3 ;
23815 int ecode3 = 0 ;
23816 int val4 ;
23817 int ecode4 = 0 ;
23818 PyObject * obj0 = 0 ;
23819 PyObject * obj1 = 0 ;
23820 PyObject * obj2 = 0 ;
23821 PyObject * obj3 = 0 ;
23822 char * kwnames[] = {
23823 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23824 };
23825
23826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23828 if (!SWIG_IsOK(res1)) {
23829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23830 }
23831 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23832 ecode2 = SWIG_AsVal_int(obj1, &val2);
23833 if (!SWIG_IsOK(ecode2)) {
23834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23835 }
23836 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23837 if (obj2) {
23838 ecode3 = SWIG_AsVal_int(obj2, &val3);
23839 if (!SWIG_IsOK(ecode3)) {
23840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23841 }
23842 arg3 = static_cast< wxDateTime::Month >(val3);
23843 }
23844 if (obj3) {
23845 ecode4 = SWIG_AsVal_int(obj3, &val4);
23846 if (!SWIG_IsOK(ecode4)) {
23847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23848 }
23849 arg4 = static_cast< int >(val4);
23850 }
23851 {
23852 PyThreadState* __tstate = wxPyBeginAllowThreads();
23853 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23854 wxPyEndAllowThreads(__tstate);
23855 if (PyErr_Occurred()) SWIG_fail;
23856 }
23857 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23858 return resultobj;
23859 fail:
23860 return NULL;
23861 }
23862
23863
23864 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23865 PyObject *resultobj = 0;
23866 wxDateTime *arg1 = (wxDateTime *) 0 ;
23867 int arg2 ;
23868 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23869 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23870 bool result;
23871 void *argp1 = 0 ;
23872 int res1 = 0 ;
23873 int val2 ;
23874 int ecode2 = 0 ;
23875 int val3 ;
23876 int ecode3 = 0 ;
23877 int val4 ;
23878 int ecode4 = 0 ;
23879 PyObject * obj0 = 0 ;
23880 PyObject * obj1 = 0 ;
23881 PyObject * obj2 = 0 ;
23882 PyObject * obj3 = 0 ;
23883 char * kwnames[] = {
23884 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23885 };
23886
23887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23889 if (!SWIG_IsOK(res1)) {
23890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23891 }
23892 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23893 ecode2 = SWIG_AsVal_int(obj1, &val2);
23894 if (!SWIG_IsOK(ecode2)) {
23895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23896 }
23897 arg2 = static_cast< int >(val2);
23898 if (obj2) {
23899 ecode3 = SWIG_AsVal_int(obj2, &val3);
23900 if (!SWIG_IsOK(ecode3)) {
23901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23902 }
23903 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23904 }
23905 if (obj3) {
23906 ecode4 = SWIG_AsVal_int(obj3, &val4);
23907 if (!SWIG_IsOK(ecode4)) {
23908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23909 }
23910 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23911 }
23912 {
23913 PyThreadState* __tstate = wxPyBeginAllowThreads();
23914 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23915 wxPyEndAllowThreads(__tstate);
23916 if (PyErr_Occurred()) SWIG_fail;
23917 }
23918 {
23919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23920 }
23921 return resultobj;
23922 fail:
23923 return NULL;
23924 }
23925
23926
23927 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23928 PyObject *resultobj = 0;
23929 wxDateTime *arg1 = (wxDateTime *) 0 ;
23930 int arg2 ;
23931 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23932 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23933 wxDateTime result;
23934 void *argp1 = 0 ;
23935 int res1 = 0 ;
23936 int val2 ;
23937 int ecode2 = 0 ;
23938 int val3 ;
23939 int ecode3 = 0 ;
23940 int val4 ;
23941 int ecode4 = 0 ;
23942 PyObject * obj0 = 0 ;
23943 PyObject * obj1 = 0 ;
23944 PyObject * obj2 = 0 ;
23945 PyObject * obj3 = 0 ;
23946 char * kwnames[] = {
23947 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23948 };
23949
23950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23952 if (!SWIG_IsOK(res1)) {
23953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23954 }
23955 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23956 ecode2 = SWIG_AsVal_int(obj1, &val2);
23957 if (!SWIG_IsOK(ecode2)) {
23958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23959 }
23960 arg2 = static_cast< int >(val2);
23961 if (obj2) {
23962 ecode3 = SWIG_AsVal_int(obj2, &val3);
23963 if (!SWIG_IsOK(ecode3)) {
23964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23965 }
23966 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23967 }
23968 if (obj3) {
23969 ecode4 = SWIG_AsVal_int(obj3, &val4);
23970 if (!SWIG_IsOK(ecode4)) {
23971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23972 }
23973 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23974 }
23975 {
23976 PyThreadState* __tstate = wxPyBeginAllowThreads();
23977 result = (arg1)->GetWeek(arg2,arg3,arg4);
23978 wxPyEndAllowThreads(__tstate);
23979 if (PyErr_Occurred()) SWIG_fail;
23980 }
23981 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23982 return resultobj;
23983 fail:
23984 return NULL;
23985 }
23986
23987
23988 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23989 PyObject *resultobj = 0;
23990 int arg1 ;
23991 int arg2 ;
23992 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23993 wxDateTime result;
23994 int val1 ;
23995 int ecode1 = 0 ;
23996 int val2 ;
23997 int ecode2 = 0 ;
23998 int val3 ;
23999 int ecode3 = 0 ;
24000 PyObject * obj0 = 0 ;
24001 PyObject * obj1 = 0 ;
24002 PyObject * obj2 = 0 ;
24003 char * kwnames[] = {
24004 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24005 };
24006
24007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24008 ecode1 = SWIG_AsVal_int(obj0, &val1);
24009 if (!SWIG_IsOK(ecode1)) {
24010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24011 }
24012 arg1 = static_cast< int >(val1);
24013 ecode2 = SWIG_AsVal_int(obj1, &val2);
24014 if (!SWIG_IsOK(ecode2)) {
24015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24016 }
24017 arg2 = static_cast< int >(val2);
24018 if (obj2) {
24019 ecode3 = SWIG_AsVal_int(obj2, &val3);
24020 if (!SWIG_IsOK(ecode3)) {
24021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24022 }
24023 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24024 }
24025 {
24026 PyThreadState* __tstate = wxPyBeginAllowThreads();
24027 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24028 wxPyEndAllowThreads(__tstate);
24029 if (PyErr_Occurred()) SWIG_fail;
24030 }
24031 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24032 return resultobj;
24033 fail:
24034 return NULL;
24035 }
24036
24037
24038 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24039 PyObject *resultobj = 0;
24040 wxDateTime *arg1 = (wxDateTime *) 0 ;
24041 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24042 int arg3 = (int) wxDateTime::Inv_Year ;
24043 wxDateTime *result = 0 ;
24044 void *argp1 = 0 ;
24045 int res1 = 0 ;
24046 int val2 ;
24047 int ecode2 = 0 ;
24048 int val3 ;
24049 int ecode3 = 0 ;
24050 PyObject * obj0 = 0 ;
24051 PyObject * obj1 = 0 ;
24052 PyObject * obj2 = 0 ;
24053 char * kwnames[] = {
24054 (char *) "self",(char *) "month",(char *) "year", NULL
24055 };
24056
24057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24059 if (!SWIG_IsOK(res1)) {
24060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24061 }
24062 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24063 if (obj1) {
24064 ecode2 = SWIG_AsVal_int(obj1, &val2);
24065 if (!SWIG_IsOK(ecode2)) {
24066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24067 }
24068 arg2 = static_cast< wxDateTime::Month >(val2);
24069 }
24070 if (obj2) {
24071 ecode3 = SWIG_AsVal_int(obj2, &val3);
24072 if (!SWIG_IsOK(ecode3)) {
24073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24074 }
24075 arg3 = static_cast< int >(val3);
24076 }
24077 {
24078 PyThreadState* __tstate = wxPyBeginAllowThreads();
24079 {
24080 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24081 result = (wxDateTime *) &_result_ref;
24082 }
24083 wxPyEndAllowThreads(__tstate);
24084 if (PyErr_Occurred()) SWIG_fail;
24085 }
24086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24087 return resultobj;
24088 fail:
24089 return NULL;
24090 }
24091
24092
24093 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24094 PyObject *resultobj = 0;
24095 wxDateTime *arg1 = (wxDateTime *) 0 ;
24096 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24097 int arg3 = (int) wxDateTime::Inv_Year ;
24098 wxDateTime result;
24099 void *argp1 = 0 ;
24100 int res1 = 0 ;
24101 int val2 ;
24102 int ecode2 = 0 ;
24103 int val3 ;
24104 int ecode3 = 0 ;
24105 PyObject * obj0 = 0 ;
24106 PyObject * obj1 = 0 ;
24107 PyObject * obj2 = 0 ;
24108 char * kwnames[] = {
24109 (char *) "self",(char *) "month",(char *) "year", NULL
24110 };
24111
24112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24114 if (!SWIG_IsOK(res1)) {
24115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24116 }
24117 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24118 if (obj1) {
24119 ecode2 = SWIG_AsVal_int(obj1, &val2);
24120 if (!SWIG_IsOK(ecode2)) {
24121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24122 }
24123 arg2 = static_cast< wxDateTime::Month >(val2);
24124 }
24125 if (obj2) {
24126 ecode3 = SWIG_AsVal_int(obj2, &val3);
24127 if (!SWIG_IsOK(ecode3)) {
24128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24129 }
24130 arg3 = static_cast< int >(val3);
24131 }
24132 {
24133 PyThreadState* __tstate = wxPyBeginAllowThreads();
24134 result = (arg1)->GetLastMonthDay(arg2,arg3);
24135 wxPyEndAllowThreads(__tstate);
24136 if (PyErr_Occurred()) SWIG_fail;
24137 }
24138 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24139 return resultobj;
24140 fail:
24141 return NULL;
24142 }
24143
24144
24145 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24146 PyObject *resultobj = 0;
24147 wxDateTime *arg1 = (wxDateTime *) 0 ;
24148 int arg2 ;
24149 wxDateTime *result = 0 ;
24150 void *argp1 = 0 ;
24151 int res1 = 0 ;
24152 int val2 ;
24153 int ecode2 = 0 ;
24154 PyObject * obj0 = 0 ;
24155 PyObject * obj1 = 0 ;
24156 char * kwnames[] = {
24157 (char *) "self",(char *) "yday", NULL
24158 };
24159
24160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24162 if (!SWIG_IsOK(res1)) {
24163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24164 }
24165 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24166 ecode2 = SWIG_AsVal_int(obj1, &val2);
24167 if (!SWIG_IsOK(ecode2)) {
24168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24169 }
24170 arg2 = static_cast< int >(val2);
24171 {
24172 PyThreadState* __tstate = wxPyBeginAllowThreads();
24173 {
24174 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24175 result = (wxDateTime *) &_result_ref;
24176 }
24177 wxPyEndAllowThreads(__tstate);
24178 if (PyErr_Occurred()) SWIG_fail;
24179 }
24180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24181 return resultobj;
24182 fail:
24183 return NULL;
24184 }
24185
24186
24187 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24188 PyObject *resultobj = 0;
24189 wxDateTime *arg1 = (wxDateTime *) 0 ;
24190 int arg2 ;
24191 wxDateTime result;
24192 void *argp1 = 0 ;
24193 int res1 = 0 ;
24194 int val2 ;
24195 int ecode2 = 0 ;
24196 PyObject * obj0 = 0 ;
24197 PyObject * obj1 = 0 ;
24198 char * kwnames[] = {
24199 (char *) "self",(char *) "yday", NULL
24200 };
24201
24202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24204 if (!SWIG_IsOK(res1)) {
24205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24206 }
24207 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24208 ecode2 = SWIG_AsVal_int(obj1, &val2);
24209 if (!SWIG_IsOK(ecode2)) {
24210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24211 }
24212 arg2 = static_cast< int >(val2);
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 result = (arg1)->GetYearDay(arg2);
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24220 return resultobj;
24221 fail:
24222 return NULL;
24223 }
24224
24225
24226 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24227 PyObject *resultobj = 0;
24228 wxDateTime *arg1 = (wxDateTime *) 0 ;
24229 double result;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 PyObject *swig_obj[1] ;
24233
24234 if (!args) SWIG_fail;
24235 swig_obj[0] = args;
24236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24237 if (!SWIG_IsOK(res1)) {
24238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24239 }
24240 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24241 {
24242 PyThreadState* __tstate = wxPyBeginAllowThreads();
24243 result = (double)(arg1)->GetJulianDayNumber();
24244 wxPyEndAllowThreads(__tstate);
24245 if (PyErr_Occurred()) SWIG_fail;
24246 }
24247 resultobj = SWIG_From_double(static_cast< double >(result));
24248 return resultobj;
24249 fail:
24250 return NULL;
24251 }
24252
24253
24254 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24255 PyObject *resultobj = 0;
24256 wxDateTime *arg1 = (wxDateTime *) 0 ;
24257 double result;
24258 void *argp1 = 0 ;
24259 int res1 = 0 ;
24260 PyObject *swig_obj[1] ;
24261
24262 if (!args) SWIG_fail;
24263 swig_obj[0] = args;
24264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24265 if (!SWIG_IsOK(res1)) {
24266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24267 }
24268 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24269 {
24270 PyThreadState* __tstate = wxPyBeginAllowThreads();
24271 result = (double)(arg1)->GetJDN();
24272 wxPyEndAllowThreads(__tstate);
24273 if (PyErr_Occurred()) SWIG_fail;
24274 }
24275 resultobj = SWIG_From_double(static_cast< double >(result));
24276 return resultobj;
24277 fail:
24278 return NULL;
24279 }
24280
24281
24282 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24283 PyObject *resultobj = 0;
24284 wxDateTime *arg1 = (wxDateTime *) 0 ;
24285 double result;
24286 void *argp1 = 0 ;
24287 int res1 = 0 ;
24288 PyObject *swig_obj[1] ;
24289
24290 if (!args) SWIG_fail;
24291 swig_obj[0] = args;
24292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24293 if (!SWIG_IsOK(res1)) {
24294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24295 }
24296 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 resultobj = SWIG_From_double(static_cast< double >(result));
24304 return resultobj;
24305 fail:
24306 return NULL;
24307 }
24308
24309
24310 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24311 PyObject *resultobj = 0;
24312 wxDateTime *arg1 = (wxDateTime *) 0 ;
24313 double result;
24314 void *argp1 = 0 ;
24315 int res1 = 0 ;
24316 PyObject *swig_obj[1] ;
24317
24318 if (!args) SWIG_fail;
24319 swig_obj[0] = args;
24320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24321 if (!SWIG_IsOK(res1)) {
24322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24323 }
24324 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24325 {
24326 PyThreadState* __tstate = wxPyBeginAllowThreads();
24327 result = (double)(arg1)->GetMJD();
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 resultobj = SWIG_From_double(static_cast< double >(result));
24332 return resultobj;
24333 fail:
24334 return NULL;
24335 }
24336
24337
24338 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24339 PyObject *resultobj = 0;
24340 wxDateTime *arg1 = (wxDateTime *) 0 ;
24341 double result;
24342 void *argp1 = 0 ;
24343 int res1 = 0 ;
24344 PyObject *swig_obj[1] ;
24345
24346 if (!args) SWIG_fail;
24347 swig_obj[0] = args;
24348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24349 if (!SWIG_IsOK(res1)) {
24350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24351 }
24352 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 result = (double)(arg1)->GetRataDie();
24356 wxPyEndAllowThreads(__tstate);
24357 if (PyErr_Occurred()) SWIG_fail;
24358 }
24359 resultobj = SWIG_From_double(static_cast< double >(result));
24360 return resultobj;
24361 fail:
24362 return NULL;
24363 }
24364
24365
24366 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24367 PyObject *resultobj = 0;
24368 wxDateTime *arg1 = (wxDateTime *) 0 ;
24369 wxDateTime::TimeZone *arg2 = 0 ;
24370 bool arg3 = (bool) false ;
24371 wxDateTime result;
24372 void *argp1 = 0 ;
24373 int res1 = 0 ;
24374 bool temp2 = false ;
24375 bool val3 ;
24376 int ecode3 = 0 ;
24377 PyObject * obj0 = 0 ;
24378 PyObject * obj1 = 0 ;
24379 PyObject * obj2 = 0 ;
24380 char * kwnames[] = {
24381 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24382 };
24383
24384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24386 if (!SWIG_IsOK(res1)) {
24387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24388 }
24389 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24390 {
24391 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24392 temp2 = true;
24393 }
24394 if (obj2) {
24395 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24396 if (!SWIG_IsOK(ecode3)) {
24397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24398 }
24399 arg3 = static_cast< bool >(val3);
24400 }
24401 {
24402 PyThreadState* __tstate = wxPyBeginAllowThreads();
24403 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24404 wxPyEndAllowThreads(__tstate);
24405 if (PyErr_Occurred()) SWIG_fail;
24406 }
24407 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24408 {
24409 if (temp2) delete arg2;
24410 }
24411 return resultobj;
24412 fail:
24413 {
24414 if (temp2) delete arg2;
24415 }
24416 return NULL;
24417 }
24418
24419
24420 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24421 PyObject *resultobj = 0;
24422 wxDateTime *arg1 = (wxDateTime *) 0 ;
24423 wxDateTime::TimeZone *arg2 = 0 ;
24424 bool arg3 = (bool) false ;
24425 wxDateTime *result = 0 ;
24426 void *argp1 = 0 ;
24427 int res1 = 0 ;
24428 bool temp2 = false ;
24429 bool val3 ;
24430 int ecode3 = 0 ;
24431 PyObject * obj0 = 0 ;
24432 PyObject * obj1 = 0 ;
24433 PyObject * obj2 = 0 ;
24434 char * kwnames[] = {
24435 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24436 };
24437
24438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24440 if (!SWIG_IsOK(res1)) {
24441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24442 }
24443 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24444 {
24445 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24446 temp2 = true;
24447 }
24448 if (obj2) {
24449 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24450 if (!SWIG_IsOK(ecode3)) {
24451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24452 }
24453 arg3 = static_cast< bool >(val3);
24454 }
24455 {
24456 PyThreadState* __tstate = wxPyBeginAllowThreads();
24457 {
24458 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24459 result = (wxDateTime *) &_result_ref;
24460 }
24461 wxPyEndAllowThreads(__tstate);
24462 if (PyErr_Occurred()) SWIG_fail;
24463 }
24464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24465 {
24466 if (temp2) delete arg2;
24467 }
24468 return resultobj;
24469 fail:
24470 {
24471 if (temp2) delete arg2;
24472 }
24473 return NULL;
24474 }
24475
24476
24477 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24478 PyObject *resultobj = 0;
24479 wxDateTime *arg1 = (wxDateTime *) 0 ;
24480 wxDateTime::TimeZone *arg2 = 0 ;
24481 bool arg3 = (bool) false ;
24482 wxDateTime result;
24483 void *argp1 = 0 ;
24484 int res1 = 0 ;
24485 bool temp2 = false ;
24486 bool val3 ;
24487 int ecode3 = 0 ;
24488 PyObject * obj0 = 0 ;
24489 PyObject * obj1 = 0 ;
24490 PyObject * obj2 = 0 ;
24491 char * kwnames[] = {
24492 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24493 };
24494
24495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24497 if (!SWIG_IsOK(res1)) {
24498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24499 }
24500 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24501 {
24502 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24503 temp2 = true;
24504 }
24505 if (obj2) {
24506 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24507 if (!SWIG_IsOK(ecode3)) {
24508 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24509 }
24510 arg3 = static_cast< bool >(val3);
24511 }
24512 {
24513 PyThreadState* __tstate = wxPyBeginAllowThreads();
24514 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24515 wxPyEndAllowThreads(__tstate);
24516 if (PyErr_Occurred()) SWIG_fail;
24517 }
24518 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24519 {
24520 if (temp2) delete arg2;
24521 }
24522 return resultobj;
24523 fail:
24524 {
24525 if (temp2) delete arg2;
24526 }
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24532 PyObject *resultobj = 0;
24533 wxDateTime *arg1 = (wxDateTime *) 0 ;
24534 wxDateTime::TimeZone *arg2 = 0 ;
24535 bool arg3 = (bool) false ;
24536 wxDateTime *result = 0 ;
24537 void *argp1 = 0 ;
24538 int res1 = 0 ;
24539 bool temp2 = false ;
24540 bool val3 ;
24541 int ecode3 = 0 ;
24542 PyObject * obj0 = 0 ;
24543 PyObject * obj1 = 0 ;
24544 PyObject * obj2 = 0 ;
24545 char * kwnames[] = {
24546 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24547 };
24548
24549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24551 if (!SWIG_IsOK(res1)) {
24552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24553 }
24554 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24555 {
24556 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24557 temp2 = true;
24558 }
24559 if (obj2) {
24560 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24561 if (!SWIG_IsOK(ecode3)) {
24562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24563 }
24564 arg3 = static_cast< bool >(val3);
24565 }
24566 {
24567 PyThreadState* __tstate = wxPyBeginAllowThreads();
24568 {
24569 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24570 result = (wxDateTime *) &_result_ref;
24571 }
24572 wxPyEndAllowThreads(__tstate);
24573 if (PyErr_Occurred()) SWIG_fail;
24574 }
24575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24576 {
24577 if (temp2) delete arg2;
24578 }
24579 return resultobj;
24580 fail:
24581 {
24582 if (temp2) delete arg2;
24583 }
24584 return NULL;
24585 }
24586
24587
24588 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24589 PyObject *resultobj = 0;
24590 wxDateTime *arg1 = (wxDateTime *) 0 ;
24591 bool arg2 = (bool) false ;
24592 wxDateTime result;
24593 void *argp1 = 0 ;
24594 int res1 = 0 ;
24595 bool val2 ;
24596 int ecode2 = 0 ;
24597 PyObject * obj0 = 0 ;
24598 PyObject * obj1 = 0 ;
24599 char * kwnames[] = {
24600 (char *) "self",(char *) "noDST", NULL
24601 };
24602
24603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24605 if (!SWIG_IsOK(res1)) {
24606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24607 }
24608 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24609 if (obj1) {
24610 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24611 if (!SWIG_IsOK(ecode2)) {
24612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24613 }
24614 arg2 = static_cast< bool >(val2);
24615 }
24616 {
24617 PyThreadState* __tstate = wxPyBeginAllowThreads();
24618 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24619 wxPyEndAllowThreads(__tstate);
24620 if (PyErr_Occurred()) SWIG_fail;
24621 }
24622 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24623 return resultobj;
24624 fail:
24625 return NULL;
24626 }
24627
24628
24629 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24630 PyObject *resultobj = 0;
24631 wxDateTime *arg1 = (wxDateTime *) 0 ;
24632 bool arg2 = (bool) false ;
24633 wxDateTime *result = 0 ;
24634 void *argp1 = 0 ;
24635 int res1 = 0 ;
24636 bool val2 ;
24637 int ecode2 = 0 ;
24638 PyObject * obj0 = 0 ;
24639 PyObject * obj1 = 0 ;
24640 char * kwnames[] = {
24641 (char *) "self",(char *) "noDST", NULL
24642 };
24643
24644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24646 if (!SWIG_IsOK(res1)) {
24647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24648 }
24649 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24650 if (obj1) {
24651 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24652 if (!SWIG_IsOK(ecode2)) {
24653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24654 }
24655 arg2 = static_cast< bool >(val2);
24656 }
24657 {
24658 PyThreadState* __tstate = wxPyBeginAllowThreads();
24659 {
24660 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24661 result = (wxDateTime *) &_result_ref;
24662 }
24663 wxPyEndAllowThreads(__tstate);
24664 if (PyErr_Occurred()) SWIG_fail;
24665 }
24666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24667 return resultobj;
24668 fail:
24669 return NULL;
24670 }
24671
24672
24673 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24674 PyObject *resultobj = 0;
24675 wxDateTime *arg1 = (wxDateTime *) 0 ;
24676 bool arg2 = (bool) false ;
24677 wxDateTime result;
24678 void *argp1 = 0 ;
24679 int res1 = 0 ;
24680 bool val2 ;
24681 int ecode2 = 0 ;
24682 PyObject * obj0 = 0 ;
24683 PyObject * obj1 = 0 ;
24684 char * kwnames[] = {
24685 (char *) "self",(char *) "noDST", NULL
24686 };
24687
24688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24690 if (!SWIG_IsOK(res1)) {
24691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24692 }
24693 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24694 if (obj1) {
24695 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24696 if (!SWIG_IsOK(ecode2)) {
24697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24698 }
24699 arg2 = static_cast< bool >(val2);
24700 }
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24708 return resultobj;
24709 fail:
24710 return NULL;
24711 }
24712
24713
24714 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj = 0;
24716 wxDateTime *arg1 = (wxDateTime *) 0 ;
24717 bool arg2 = (bool) false ;
24718 wxDateTime *result = 0 ;
24719 void *argp1 = 0 ;
24720 int res1 = 0 ;
24721 bool val2 ;
24722 int ecode2 = 0 ;
24723 PyObject * obj0 = 0 ;
24724 PyObject * obj1 = 0 ;
24725 char * kwnames[] = {
24726 (char *) "self",(char *) "noDST", NULL
24727 };
24728
24729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24731 if (!SWIG_IsOK(res1)) {
24732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24733 }
24734 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24735 if (obj1) {
24736 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24737 if (!SWIG_IsOK(ecode2)) {
24738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24739 }
24740 arg2 = static_cast< bool >(val2);
24741 }
24742 {
24743 PyThreadState* __tstate = wxPyBeginAllowThreads();
24744 {
24745 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24746 result = (wxDateTime *) &_result_ref;
24747 }
24748 wxPyEndAllowThreads(__tstate);
24749 if (PyErr_Occurred()) SWIG_fail;
24750 }
24751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24752 return resultobj;
24753 fail:
24754 return NULL;
24755 }
24756
24757
24758 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24759 PyObject *resultobj = 0;
24760 wxDateTime *arg1 = (wxDateTime *) 0 ;
24761 bool arg2 = (bool) false ;
24762 wxDateTime result;
24763 void *argp1 = 0 ;
24764 int res1 = 0 ;
24765 bool val2 ;
24766 int ecode2 = 0 ;
24767 PyObject * obj0 = 0 ;
24768 PyObject * obj1 = 0 ;
24769 char * kwnames[] = {
24770 (char *) "self",(char *) "noDST", NULL
24771 };
24772
24773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24775 if (!SWIG_IsOK(res1)) {
24776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24777 }
24778 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24779 if (obj1) {
24780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24781 if (!SWIG_IsOK(ecode2)) {
24782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24783 }
24784 arg2 = static_cast< bool >(val2);
24785 }
24786 {
24787 PyThreadState* __tstate = wxPyBeginAllowThreads();
24788 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24789 wxPyEndAllowThreads(__tstate);
24790 if (PyErr_Occurred()) SWIG_fail;
24791 }
24792 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24793 return resultobj;
24794 fail:
24795 return NULL;
24796 }
24797
24798
24799 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24800 PyObject *resultobj = 0;
24801 wxDateTime *arg1 = (wxDateTime *) 0 ;
24802 bool arg2 = (bool) false ;
24803 wxDateTime *result = 0 ;
24804 void *argp1 = 0 ;
24805 int res1 = 0 ;
24806 bool val2 ;
24807 int ecode2 = 0 ;
24808 PyObject * obj0 = 0 ;
24809 PyObject * obj1 = 0 ;
24810 char * kwnames[] = {
24811 (char *) "self",(char *) "noDST", NULL
24812 };
24813
24814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24816 if (!SWIG_IsOK(res1)) {
24817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24818 }
24819 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24820 if (obj1) {
24821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24822 if (!SWIG_IsOK(ecode2)) {
24823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24824 }
24825 arg2 = static_cast< bool >(val2);
24826 }
24827 {
24828 PyThreadState* __tstate = wxPyBeginAllowThreads();
24829 {
24830 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24831 result = (wxDateTime *) &_result_ref;
24832 }
24833 wxPyEndAllowThreads(__tstate);
24834 if (PyErr_Occurred()) SWIG_fail;
24835 }
24836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24837 return resultobj;
24838 fail:
24839 return NULL;
24840 }
24841
24842
24843 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24844 PyObject *resultobj = 0;
24845 wxDateTime *arg1 = (wxDateTime *) 0 ;
24846 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24847 int result;
24848 void *argp1 = 0 ;
24849 int res1 = 0 ;
24850 int val2 ;
24851 int ecode2 = 0 ;
24852 PyObject * obj0 = 0 ;
24853 PyObject * obj1 = 0 ;
24854 char * kwnames[] = {
24855 (char *) "self",(char *) "country", NULL
24856 };
24857
24858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24860 if (!SWIG_IsOK(res1)) {
24861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24862 }
24863 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24864 if (obj1) {
24865 ecode2 = SWIG_AsVal_int(obj1, &val2);
24866 if (!SWIG_IsOK(ecode2)) {
24867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24868 }
24869 arg2 = static_cast< wxDateTime::Country >(val2);
24870 }
24871 {
24872 PyThreadState* __tstate = wxPyBeginAllowThreads();
24873 result = (int)(arg1)->IsDST(arg2);
24874 wxPyEndAllowThreads(__tstate);
24875 if (PyErr_Occurred()) SWIG_fail;
24876 }
24877 resultobj = SWIG_From_int(static_cast< int >(result));
24878 return resultobj;
24879 fail:
24880 return NULL;
24881 }
24882
24883
24884 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24885 PyObject *resultobj = 0;
24886 wxDateTime *arg1 = (wxDateTime *) 0 ;
24887 bool result;
24888 void *argp1 = 0 ;
24889 int res1 = 0 ;
24890 PyObject *swig_obj[1] ;
24891
24892 if (!args) SWIG_fail;
24893 swig_obj[0] = args;
24894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24895 if (!SWIG_IsOK(res1)) {
24896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24897 }
24898 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24899 {
24900 PyThreadState* __tstate = wxPyBeginAllowThreads();
24901 result = (bool)((wxDateTime const *)arg1)->IsValid();
24902 wxPyEndAllowThreads(__tstate);
24903 if (PyErr_Occurred()) SWIG_fail;
24904 }
24905 {
24906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24907 }
24908 return resultobj;
24909 fail:
24910 return NULL;
24911 }
24912
24913
24914 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24915 PyObject *resultobj = 0;
24916 wxDateTime *arg1 = (wxDateTime *) 0 ;
24917 time_t result;
24918 void *argp1 = 0 ;
24919 int res1 = 0 ;
24920 PyObject *swig_obj[1] ;
24921
24922 if (!args) SWIG_fail;
24923 swig_obj[0] = args;
24924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24925 if (!SWIG_IsOK(res1)) {
24926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24927 }
24928 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24929 {
24930 PyThreadState* __tstate = wxPyBeginAllowThreads();
24931 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24932 wxPyEndAllowThreads(__tstate);
24933 if (PyErr_Occurred()) SWIG_fail;
24934 }
24935 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24936 return resultobj;
24937 fail:
24938 return NULL;
24939 }
24940
24941
24942 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24943 PyObject *resultobj = 0;
24944 wxDateTime *arg1 = (wxDateTime *) 0 ;
24945 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24946 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24947 int result;
24948 void *argp1 = 0 ;
24949 int res1 = 0 ;
24950 bool temp2 = false ;
24951 PyObject * obj0 = 0 ;
24952 PyObject * obj1 = 0 ;
24953 char * kwnames[] = {
24954 (char *) "self",(char *) "tz", NULL
24955 };
24956
24957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24959 if (!SWIG_IsOK(res1)) {
24960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24961 }
24962 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24963 if (obj1) {
24964 {
24965 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24966 temp2 = true;
24967 }
24968 }
24969 {
24970 PyThreadState* __tstate = wxPyBeginAllowThreads();
24971 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 resultobj = SWIG_From_int(static_cast< int >(result));
24976 {
24977 if (temp2) delete arg2;
24978 }
24979 return resultobj;
24980 fail:
24981 {
24982 if (temp2) delete arg2;
24983 }
24984 return NULL;
24985 }
24986
24987
24988 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24989 PyObject *resultobj = 0;
24990 wxDateTime *arg1 = (wxDateTime *) 0 ;
24991 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24992 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24993 wxDateTime::Month result;
24994 void *argp1 = 0 ;
24995 int res1 = 0 ;
24996 bool temp2 = false ;
24997 PyObject * obj0 = 0 ;
24998 PyObject * obj1 = 0 ;
24999 char * kwnames[] = {
25000 (char *) "self",(char *) "tz", NULL
25001 };
25002
25003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25005 if (!SWIG_IsOK(res1)) {
25006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25007 }
25008 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25009 if (obj1) {
25010 {
25011 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25012 temp2 = true;
25013 }
25014 }
25015 {
25016 PyThreadState* __tstate = wxPyBeginAllowThreads();
25017 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25018 wxPyEndAllowThreads(__tstate);
25019 if (PyErr_Occurred()) SWIG_fail;
25020 }
25021 resultobj = SWIG_From_int(static_cast< int >(result));
25022 {
25023 if (temp2) delete arg2;
25024 }
25025 return resultobj;
25026 fail:
25027 {
25028 if (temp2) delete arg2;
25029 }
25030 return NULL;
25031 }
25032
25033
25034 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25035 PyObject *resultobj = 0;
25036 wxDateTime *arg1 = (wxDateTime *) 0 ;
25037 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25038 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25039 int result;
25040 void *argp1 = 0 ;
25041 int res1 = 0 ;
25042 bool temp2 = false ;
25043 PyObject * obj0 = 0 ;
25044 PyObject * obj1 = 0 ;
25045 char * kwnames[] = {
25046 (char *) "self",(char *) "tz", NULL
25047 };
25048
25049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25053 }
25054 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25055 if (obj1) {
25056 {
25057 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25058 temp2 = true;
25059 }
25060 }
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25064 wxPyEndAllowThreads(__tstate);
25065 if (PyErr_Occurred()) SWIG_fail;
25066 }
25067 resultobj = SWIG_From_int(static_cast< int >(result));
25068 {
25069 if (temp2) delete arg2;
25070 }
25071 return resultobj;
25072 fail:
25073 {
25074 if (temp2) delete arg2;
25075 }
25076 return NULL;
25077 }
25078
25079
25080 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25081 PyObject *resultobj = 0;
25082 wxDateTime *arg1 = (wxDateTime *) 0 ;
25083 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25084 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25085 wxDateTime::WeekDay result;
25086 void *argp1 = 0 ;
25087 int res1 = 0 ;
25088 bool temp2 = false ;
25089 PyObject * obj0 = 0 ;
25090 PyObject * obj1 = 0 ;
25091 char * kwnames[] = {
25092 (char *) "self",(char *) "tz", NULL
25093 };
25094
25095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25097 if (!SWIG_IsOK(res1)) {
25098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25099 }
25100 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25101 if (obj1) {
25102 {
25103 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25104 temp2 = true;
25105 }
25106 }
25107 {
25108 PyThreadState* __tstate = wxPyBeginAllowThreads();
25109 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25110 wxPyEndAllowThreads(__tstate);
25111 if (PyErr_Occurred()) SWIG_fail;
25112 }
25113 resultobj = SWIG_From_int(static_cast< int >(result));
25114 {
25115 if (temp2) delete arg2;
25116 }
25117 return resultobj;
25118 fail:
25119 {
25120 if (temp2) delete arg2;
25121 }
25122 return NULL;
25123 }
25124
25125
25126 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25127 PyObject *resultobj = 0;
25128 wxDateTime *arg1 = (wxDateTime *) 0 ;
25129 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25130 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25131 int result;
25132 void *argp1 = 0 ;
25133 int res1 = 0 ;
25134 bool temp2 = false ;
25135 PyObject * obj0 = 0 ;
25136 PyObject * obj1 = 0 ;
25137 char * kwnames[] = {
25138 (char *) "self",(char *) "tz", NULL
25139 };
25140
25141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25143 if (!SWIG_IsOK(res1)) {
25144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25145 }
25146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25147 if (obj1) {
25148 {
25149 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25150 temp2 = true;
25151 }
25152 }
25153 {
25154 PyThreadState* __tstate = wxPyBeginAllowThreads();
25155 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25156 wxPyEndAllowThreads(__tstate);
25157 if (PyErr_Occurred()) SWIG_fail;
25158 }
25159 resultobj = SWIG_From_int(static_cast< int >(result));
25160 {
25161 if (temp2) delete arg2;
25162 }
25163 return resultobj;
25164 fail:
25165 {
25166 if (temp2) delete arg2;
25167 }
25168 return NULL;
25169 }
25170
25171
25172 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25173 PyObject *resultobj = 0;
25174 wxDateTime *arg1 = (wxDateTime *) 0 ;
25175 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25176 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25177 int result;
25178 void *argp1 = 0 ;
25179 int res1 = 0 ;
25180 bool temp2 = false ;
25181 PyObject * obj0 = 0 ;
25182 PyObject * obj1 = 0 ;
25183 char * kwnames[] = {
25184 (char *) "self",(char *) "tz", NULL
25185 };
25186
25187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25189 if (!SWIG_IsOK(res1)) {
25190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25191 }
25192 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25193 if (obj1) {
25194 {
25195 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25196 temp2 = true;
25197 }
25198 }
25199 {
25200 PyThreadState* __tstate = wxPyBeginAllowThreads();
25201 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25202 wxPyEndAllowThreads(__tstate);
25203 if (PyErr_Occurred()) SWIG_fail;
25204 }
25205 resultobj = SWIG_From_int(static_cast< int >(result));
25206 {
25207 if (temp2) delete arg2;
25208 }
25209 return resultobj;
25210 fail:
25211 {
25212 if (temp2) delete arg2;
25213 }
25214 return NULL;
25215 }
25216
25217
25218 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25219 PyObject *resultobj = 0;
25220 wxDateTime *arg1 = (wxDateTime *) 0 ;
25221 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25222 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25223 int result;
25224 void *argp1 = 0 ;
25225 int res1 = 0 ;
25226 bool temp2 = false ;
25227 PyObject * obj0 = 0 ;
25228 PyObject * obj1 = 0 ;
25229 char * kwnames[] = {
25230 (char *) "self",(char *) "tz", NULL
25231 };
25232
25233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25235 if (!SWIG_IsOK(res1)) {
25236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25237 }
25238 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25239 if (obj1) {
25240 {
25241 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25242 temp2 = true;
25243 }
25244 }
25245 {
25246 PyThreadState* __tstate = wxPyBeginAllowThreads();
25247 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25248 wxPyEndAllowThreads(__tstate);
25249 if (PyErr_Occurred()) SWIG_fail;
25250 }
25251 resultobj = SWIG_From_int(static_cast< int >(result));
25252 {
25253 if (temp2) delete arg2;
25254 }
25255 return resultobj;
25256 fail:
25257 {
25258 if (temp2) delete arg2;
25259 }
25260 return NULL;
25261 }
25262
25263
25264 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25265 PyObject *resultobj = 0;
25266 wxDateTime *arg1 = (wxDateTime *) 0 ;
25267 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25268 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25269 int result;
25270 void *argp1 = 0 ;
25271 int res1 = 0 ;
25272 bool temp2 = false ;
25273 PyObject * obj0 = 0 ;
25274 PyObject * obj1 = 0 ;
25275 char * kwnames[] = {
25276 (char *) "self",(char *) "tz", NULL
25277 };
25278
25279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25281 if (!SWIG_IsOK(res1)) {
25282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25283 }
25284 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25285 if (obj1) {
25286 {
25287 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25288 temp2 = true;
25289 }
25290 }
25291 {
25292 PyThreadState* __tstate = wxPyBeginAllowThreads();
25293 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25294 wxPyEndAllowThreads(__tstate);
25295 if (PyErr_Occurred()) SWIG_fail;
25296 }
25297 resultobj = SWIG_From_int(static_cast< int >(result));
25298 {
25299 if (temp2) delete arg2;
25300 }
25301 return resultobj;
25302 fail:
25303 {
25304 if (temp2) delete arg2;
25305 }
25306 return NULL;
25307 }
25308
25309
25310 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25311 PyObject *resultobj = 0;
25312 wxDateTime *arg1 = (wxDateTime *) 0 ;
25313 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25314 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25315 int result;
25316 void *argp1 = 0 ;
25317 int res1 = 0 ;
25318 bool temp2 = false ;
25319 PyObject * obj0 = 0 ;
25320 PyObject * obj1 = 0 ;
25321 char * kwnames[] = {
25322 (char *) "self",(char *) "tz", NULL
25323 };
25324
25325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25327 if (!SWIG_IsOK(res1)) {
25328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25329 }
25330 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25331 if (obj1) {
25332 {
25333 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25334 temp2 = true;
25335 }
25336 }
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 resultobj = SWIG_From_int(static_cast< int >(result));
25344 {
25345 if (temp2) delete arg2;
25346 }
25347 return resultobj;
25348 fail:
25349 {
25350 if (temp2) delete arg2;
25351 }
25352 return NULL;
25353 }
25354
25355
25356 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25357 PyObject *resultobj = 0;
25358 wxDateTime *arg1 = (wxDateTime *) 0 ;
25359 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25360 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25361 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25362 int result;
25363 void *argp1 = 0 ;
25364 int res1 = 0 ;
25365 int val2 ;
25366 int ecode2 = 0 ;
25367 bool temp3 = false ;
25368 PyObject * obj0 = 0 ;
25369 PyObject * obj1 = 0 ;
25370 PyObject * obj2 = 0 ;
25371 char * kwnames[] = {
25372 (char *) "self",(char *) "flags",(char *) "tz", NULL
25373 };
25374
25375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25377 if (!SWIG_IsOK(res1)) {
25378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25379 }
25380 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25381 if (obj1) {
25382 ecode2 = SWIG_AsVal_int(obj1, &val2);
25383 if (!SWIG_IsOK(ecode2)) {
25384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25385 }
25386 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25387 }
25388 if (obj2) {
25389 {
25390 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25391 temp3 = true;
25392 }
25393 }
25394 {
25395 PyThreadState* __tstate = wxPyBeginAllowThreads();
25396 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 resultobj = SWIG_From_int(static_cast< int >(result));
25401 {
25402 if (temp3) delete arg3;
25403 }
25404 return resultobj;
25405 fail:
25406 {
25407 if (temp3) delete arg3;
25408 }
25409 return NULL;
25410 }
25411
25412
25413 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25414 PyObject *resultobj = 0;
25415 wxDateTime *arg1 = (wxDateTime *) 0 ;
25416 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25417 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25418 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25419 int result;
25420 void *argp1 = 0 ;
25421 int res1 = 0 ;
25422 int val2 ;
25423 int ecode2 = 0 ;
25424 bool temp3 = false ;
25425 PyObject * obj0 = 0 ;
25426 PyObject * obj1 = 0 ;
25427 PyObject * obj2 = 0 ;
25428 char * kwnames[] = {
25429 (char *) "self",(char *) "flags",(char *) "tz", NULL
25430 };
25431
25432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25434 if (!SWIG_IsOK(res1)) {
25435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25436 }
25437 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25438 if (obj1) {
25439 ecode2 = SWIG_AsVal_int(obj1, &val2);
25440 if (!SWIG_IsOK(ecode2)) {
25441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25442 }
25443 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25444 }
25445 if (obj2) {
25446 {
25447 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25448 temp3 = true;
25449 }
25450 }
25451 {
25452 PyThreadState* __tstate = wxPyBeginAllowThreads();
25453 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25454 wxPyEndAllowThreads(__tstate);
25455 if (PyErr_Occurred()) SWIG_fail;
25456 }
25457 resultobj = SWIG_From_int(static_cast< int >(result));
25458 {
25459 if (temp3) delete arg3;
25460 }
25461 return resultobj;
25462 fail:
25463 {
25464 if (temp3) delete arg3;
25465 }
25466 return NULL;
25467 }
25468
25469
25470 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25471 PyObject *resultobj = 0;
25472 wxDateTime *arg1 = (wxDateTime *) 0 ;
25473 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25474 bool result;
25475 void *argp1 = 0 ;
25476 int res1 = 0 ;
25477 int val2 ;
25478 int ecode2 = 0 ;
25479 PyObject * obj0 = 0 ;
25480 PyObject * obj1 = 0 ;
25481 char * kwnames[] = {
25482 (char *) "self",(char *) "country", NULL
25483 };
25484
25485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25487 if (!SWIG_IsOK(res1)) {
25488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25489 }
25490 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25491 if (obj1) {
25492 ecode2 = SWIG_AsVal_int(obj1, &val2);
25493 if (!SWIG_IsOK(ecode2)) {
25494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25495 }
25496 arg2 = static_cast< wxDateTime::Country >(val2);
25497 }
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 {
25505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25506 }
25507 return resultobj;
25508 fail:
25509 return NULL;
25510 }
25511
25512
25513 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25514 PyObject *resultobj = 0;
25515 wxDateTime *arg1 = (wxDateTime *) 0 ;
25516 wxDateTime *arg2 = 0 ;
25517 bool result;
25518 void *argp1 = 0 ;
25519 int res1 = 0 ;
25520 void *argp2 = 0 ;
25521 int res2 = 0 ;
25522 PyObject * obj0 = 0 ;
25523 PyObject * obj1 = 0 ;
25524 char * kwnames[] = {
25525 (char *) "self",(char *) "datetime", NULL
25526 };
25527
25528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25530 if (!SWIG_IsOK(res1)) {
25531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25532 }
25533 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25534 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25535 if (!SWIG_IsOK(res2)) {
25536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25537 }
25538 if (!argp2) {
25539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25540 }
25541 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25542 {
25543 PyThreadState* __tstate = wxPyBeginAllowThreads();
25544 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25545 wxPyEndAllowThreads(__tstate);
25546 if (PyErr_Occurred()) SWIG_fail;
25547 }
25548 {
25549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25550 }
25551 return resultobj;
25552 fail:
25553 return NULL;
25554 }
25555
25556
25557 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25558 PyObject *resultobj = 0;
25559 wxDateTime *arg1 = (wxDateTime *) 0 ;
25560 wxDateTime *arg2 = 0 ;
25561 bool result;
25562 void *argp1 = 0 ;
25563 int res1 = 0 ;
25564 void *argp2 = 0 ;
25565 int res2 = 0 ;
25566 PyObject * obj0 = 0 ;
25567 PyObject * obj1 = 0 ;
25568 char * kwnames[] = {
25569 (char *) "self",(char *) "datetime", NULL
25570 };
25571
25572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25574 if (!SWIG_IsOK(res1)) {
25575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25576 }
25577 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25578 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25579 if (!SWIG_IsOK(res2)) {
25580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25581 }
25582 if (!argp2) {
25583 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25584 }
25585 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25586 {
25587 PyThreadState* __tstate = wxPyBeginAllowThreads();
25588 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25589 wxPyEndAllowThreads(__tstate);
25590 if (PyErr_Occurred()) SWIG_fail;
25591 }
25592 {
25593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25594 }
25595 return resultobj;
25596 fail:
25597 return NULL;
25598 }
25599
25600
25601 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25602 PyObject *resultobj = 0;
25603 wxDateTime *arg1 = (wxDateTime *) 0 ;
25604 wxDateTime *arg2 = 0 ;
25605 bool result;
25606 void *argp1 = 0 ;
25607 int res1 = 0 ;
25608 void *argp2 = 0 ;
25609 int res2 = 0 ;
25610 PyObject * obj0 = 0 ;
25611 PyObject * obj1 = 0 ;
25612 char * kwnames[] = {
25613 (char *) "self",(char *) "datetime", NULL
25614 };
25615
25616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25618 if (!SWIG_IsOK(res1)) {
25619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25620 }
25621 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25622 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25623 if (!SWIG_IsOK(res2)) {
25624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25625 }
25626 if (!argp2) {
25627 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25628 }
25629 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25630 {
25631 PyThreadState* __tstate = wxPyBeginAllowThreads();
25632 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25633 wxPyEndAllowThreads(__tstate);
25634 if (PyErr_Occurred()) SWIG_fail;
25635 }
25636 {
25637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25638 }
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25646 PyObject *resultobj = 0;
25647 wxDateTime *arg1 = (wxDateTime *) 0 ;
25648 wxDateTime *arg2 = 0 ;
25649 wxDateTime *arg3 = 0 ;
25650 bool result;
25651 void *argp1 = 0 ;
25652 int res1 = 0 ;
25653 void *argp2 = 0 ;
25654 int res2 = 0 ;
25655 void *argp3 = 0 ;
25656 int res3 = 0 ;
25657 PyObject * obj0 = 0 ;
25658 PyObject * obj1 = 0 ;
25659 PyObject * obj2 = 0 ;
25660 char * kwnames[] = {
25661 (char *) "self",(char *) "t1",(char *) "t2", NULL
25662 };
25663
25664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25666 if (!SWIG_IsOK(res1)) {
25667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25668 }
25669 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25670 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25671 if (!SWIG_IsOK(res2)) {
25672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25673 }
25674 if (!argp2) {
25675 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25676 }
25677 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25678 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25679 if (!SWIG_IsOK(res3)) {
25680 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25681 }
25682 if (!argp3) {
25683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25684 }
25685 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25686 {
25687 PyThreadState* __tstate = wxPyBeginAllowThreads();
25688 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25689 wxPyEndAllowThreads(__tstate);
25690 if (PyErr_Occurred()) SWIG_fail;
25691 }
25692 {
25693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25694 }
25695 return resultobj;
25696 fail:
25697 return NULL;
25698 }
25699
25700
25701 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25702 PyObject *resultobj = 0;
25703 wxDateTime *arg1 = (wxDateTime *) 0 ;
25704 wxDateTime *arg2 = 0 ;
25705 wxDateTime *arg3 = 0 ;
25706 bool result;
25707 void *argp1 = 0 ;
25708 int res1 = 0 ;
25709 void *argp2 = 0 ;
25710 int res2 = 0 ;
25711 void *argp3 = 0 ;
25712 int res3 = 0 ;
25713 PyObject * obj0 = 0 ;
25714 PyObject * obj1 = 0 ;
25715 PyObject * obj2 = 0 ;
25716 char * kwnames[] = {
25717 (char *) "self",(char *) "t1",(char *) "t2", NULL
25718 };
25719
25720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25722 if (!SWIG_IsOK(res1)) {
25723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25724 }
25725 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25726 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25727 if (!SWIG_IsOK(res2)) {
25728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25729 }
25730 if (!argp2) {
25731 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25732 }
25733 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25734 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25735 if (!SWIG_IsOK(res3)) {
25736 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25737 }
25738 if (!argp3) {
25739 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25740 }
25741 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25742 {
25743 PyThreadState* __tstate = wxPyBeginAllowThreads();
25744 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25745 wxPyEndAllowThreads(__tstate);
25746 if (PyErr_Occurred()) SWIG_fail;
25747 }
25748 {
25749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25750 }
25751 return resultobj;
25752 fail:
25753 return NULL;
25754 }
25755
25756
25757 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25758 PyObject *resultobj = 0;
25759 wxDateTime *arg1 = (wxDateTime *) 0 ;
25760 wxDateTime *arg2 = 0 ;
25761 bool result;
25762 void *argp1 = 0 ;
25763 int res1 = 0 ;
25764 void *argp2 = 0 ;
25765 int res2 = 0 ;
25766 PyObject * obj0 = 0 ;
25767 PyObject * obj1 = 0 ;
25768 char * kwnames[] = {
25769 (char *) "self",(char *) "dt", NULL
25770 };
25771
25772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25774 if (!SWIG_IsOK(res1)) {
25775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25776 }
25777 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25778 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25779 if (!SWIG_IsOK(res2)) {
25780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25781 }
25782 if (!argp2) {
25783 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25784 }
25785 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25786 {
25787 PyThreadState* __tstate = wxPyBeginAllowThreads();
25788 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25789 wxPyEndAllowThreads(__tstate);
25790 if (PyErr_Occurred()) SWIG_fail;
25791 }
25792 {
25793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25794 }
25795 return resultobj;
25796 fail:
25797 return NULL;
25798 }
25799
25800
25801 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25802 PyObject *resultobj = 0;
25803 wxDateTime *arg1 = (wxDateTime *) 0 ;
25804 wxDateTime *arg2 = 0 ;
25805 bool result;
25806 void *argp1 = 0 ;
25807 int res1 = 0 ;
25808 void *argp2 = 0 ;
25809 int res2 = 0 ;
25810 PyObject * obj0 = 0 ;
25811 PyObject * obj1 = 0 ;
25812 char * kwnames[] = {
25813 (char *) "self",(char *) "dt", NULL
25814 };
25815
25816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25818 if (!SWIG_IsOK(res1)) {
25819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25820 }
25821 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25822 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25823 if (!SWIG_IsOK(res2)) {
25824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25825 }
25826 if (!argp2) {
25827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25828 }
25829 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25830 {
25831 PyThreadState* __tstate = wxPyBeginAllowThreads();
25832 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25833 wxPyEndAllowThreads(__tstate);
25834 if (PyErr_Occurred()) SWIG_fail;
25835 }
25836 {
25837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25838 }
25839 return resultobj;
25840 fail:
25841 return NULL;
25842 }
25843
25844
25845 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25846 PyObject *resultobj = 0;
25847 wxDateTime *arg1 = (wxDateTime *) 0 ;
25848 wxDateTime *arg2 = 0 ;
25849 wxTimeSpan *arg3 = 0 ;
25850 bool result;
25851 void *argp1 = 0 ;
25852 int res1 = 0 ;
25853 void *argp2 = 0 ;
25854 int res2 = 0 ;
25855 void *argp3 = 0 ;
25856 int res3 = 0 ;
25857 PyObject * obj0 = 0 ;
25858 PyObject * obj1 = 0 ;
25859 PyObject * obj2 = 0 ;
25860 char * kwnames[] = {
25861 (char *) "self",(char *) "dt",(char *) "ts", NULL
25862 };
25863
25864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25866 if (!SWIG_IsOK(res1)) {
25867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25868 }
25869 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25870 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25871 if (!SWIG_IsOK(res2)) {
25872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25873 }
25874 if (!argp2) {
25875 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25876 }
25877 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25878 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25879 if (!SWIG_IsOK(res3)) {
25880 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25881 }
25882 if (!argp3) {
25883 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25884 }
25885 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25886 {
25887 PyThreadState* __tstate = wxPyBeginAllowThreads();
25888 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25889 wxPyEndAllowThreads(__tstate);
25890 if (PyErr_Occurred()) SWIG_fail;
25891 }
25892 {
25893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25894 }
25895 return resultobj;
25896 fail:
25897 return NULL;
25898 }
25899
25900
25901 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25902 PyObject *resultobj = 0;
25903 wxDateTime *arg1 = (wxDateTime *) 0 ;
25904 wxTimeSpan *arg2 = 0 ;
25905 wxDateTime *result = 0 ;
25906 void *argp1 = 0 ;
25907 int res1 = 0 ;
25908 void *argp2 = 0 ;
25909 int res2 = 0 ;
25910 PyObject * obj0 = 0 ;
25911 PyObject * obj1 = 0 ;
25912 char * kwnames[] = {
25913 (char *) "self",(char *) "diff", NULL
25914 };
25915
25916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25918 if (!SWIG_IsOK(res1)) {
25919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25920 }
25921 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25922 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25923 if (!SWIG_IsOK(res2)) {
25924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25925 }
25926 if (!argp2) {
25927 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25928 }
25929 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25930 {
25931 PyThreadState* __tstate = wxPyBeginAllowThreads();
25932 {
25933 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25934 result = (wxDateTime *) &_result_ref;
25935 }
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25940 return resultobj;
25941 fail:
25942 return NULL;
25943 }
25944
25945
25946 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25947 PyObject *resultobj = 0;
25948 wxDateTime *arg1 = (wxDateTime *) 0 ;
25949 wxDateSpan *arg2 = 0 ;
25950 wxDateTime *result = 0 ;
25951 void *argp1 = 0 ;
25952 int res1 = 0 ;
25953 void *argp2 = 0 ;
25954 int res2 = 0 ;
25955 PyObject * obj0 = 0 ;
25956 PyObject * obj1 = 0 ;
25957 char * kwnames[] = {
25958 (char *) "self",(char *) "diff", NULL
25959 };
25960
25961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25963 if (!SWIG_IsOK(res1)) {
25964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25965 }
25966 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25967 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25968 if (!SWIG_IsOK(res2)) {
25969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25970 }
25971 if (!argp2) {
25972 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25973 }
25974 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25975 {
25976 PyThreadState* __tstate = wxPyBeginAllowThreads();
25977 {
25978 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25979 result = (wxDateTime *) &_result_ref;
25980 }
25981 wxPyEndAllowThreads(__tstate);
25982 if (PyErr_Occurred()) SWIG_fail;
25983 }
25984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25985 return resultobj;
25986 fail:
25987 return NULL;
25988 }
25989
25990
25991 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25992 PyObject *resultobj = 0;
25993 wxDateTime *arg1 = (wxDateTime *) 0 ;
25994 wxTimeSpan *arg2 = 0 ;
25995 wxDateTime *result = 0 ;
25996 void *argp1 = 0 ;
25997 int res1 = 0 ;
25998 void *argp2 = 0 ;
25999 int res2 = 0 ;
26000 PyObject * obj0 = 0 ;
26001 PyObject * obj1 = 0 ;
26002 char * kwnames[] = {
26003 (char *) "self",(char *) "diff", NULL
26004 };
26005
26006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26008 if (!SWIG_IsOK(res1)) {
26009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26010 }
26011 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26012 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26013 if (!SWIG_IsOK(res2)) {
26014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26015 }
26016 if (!argp2) {
26017 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26018 }
26019 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 {
26023 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26024 result = (wxDateTime *) &_result_ref;
26025 }
26026 wxPyEndAllowThreads(__tstate);
26027 if (PyErr_Occurred()) SWIG_fail;
26028 }
26029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26030 return resultobj;
26031 fail:
26032 return NULL;
26033 }
26034
26035
26036 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26037 PyObject *resultobj = 0;
26038 wxDateTime *arg1 = (wxDateTime *) 0 ;
26039 wxDateSpan *arg2 = 0 ;
26040 wxDateTime *result = 0 ;
26041 void *argp1 = 0 ;
26042 int res1 = 0 ;
26043 void *argp2 = 0 ;
26044 int res2 = 0 ;
26045 PyObject * obj0 = 0 ;
26046 PyObject * obj1 = 0 ;
26047 char * kwnames[] = {
26048 (char *) "self",(char *) "diff", NULL
26049 };
26050
26051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26053 if (!SWIG_IsOK(res1)) {
26054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26055 }
26056 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26057 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26058 if (!SWIG_IsOK(res2)) {
26059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26060 }
26061 if (!argp2) {
26062 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26063 }
26064 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26065 {
26066 PyThreadState* __tstate = wxPyBeginAllowThreads();
26067 {
26068 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26069 result = (wxDateTime *) &_result_ref;
26070 }
26071 wxPyEndAllowThreads(__tstate);
26072 if (PyErr_Occurred()) SWIG_fail;
26073 }
26074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26075 return resultobj;
26076 fail:
26077 return NULL;
26078 }
26079
26080
26081 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26082 PyObject *resultobj = 0;
26083 wxDateTime *arg1 = (wxDateTime *) 0 ;
26084 wxDateTime *arg2 = 0 ;
26085 wxTimeSpan result;
26086 void *argp1 = 0 ;
26087 int res1 = 0 ;
26088 void *argp2 = 0 ;
26089 int res2 = 0 ;
26090 PyObject * obj0 = 0 ;
26091 PyObject * obj1 = 0 ;
26092 char * kwnames[] = {
26093 (char *) "self",(char *) "dt", NULL
26094 };
26095
26096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26098 if (!SWIG_IsOK(res1)) {
26099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26100 }
26101 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26102 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26103 if (!SWIG_IsOK(res2)) {
26104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26105 }
26106 if (!argp2) {
26107 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26108 }
26109 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26110 {
26111 PyThreadState* __tstate = wxPyBeginAllowThreads();
26112 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26113 wxPyEndAllowThreads(__tstate);
26114 if (PyErr_Occurred()) SWIG_fail;
26115 }
26116 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26124 PyObject *resultobj = 0;
26125 wxDateTime *arg1 = (wxDateTime *) 0 ;
26126 wxTimeSpan *arg2 = 0 ;
26127 wxDateTime *result = 0 ;
26128 void *argp1 = 0 ;
26129 int res1 = 0 ;
26130 void *argp2 = 0 ;
26131 int res2 = 0 ;
26132
26133 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26135 if (!SWIG_IsOK(res1)) {
26136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26137 }
26138 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26139 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26140 if (!SWIG_IsOK(res2)) {
26141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26142 }
26143 if (!argp2) {
26144 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26145 }
26146 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26147 {
26148 PyThreadState* __tstate = wxPyBeginAllowThreads();
26149 {
26150 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26151 result = (wxDateTime *) &_result_ref;
26152 }
26153 wxPyEndAllowThreads(__tstate);
26154 if (PyErr_Occurred()) SWIG_fail;
26155 }
26156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26157 return resultobj;
26158 fail:
26159 return NULL;
26160 }
26161
26162
26163 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26164 PyObject *resultobj = 0;
26165 wxDateTime *arg1 = (wxDateTime *) 0 ;
26166 wxDateSpan *arg2 = 0 ;
26167 wxDateTime *result = 0 ;
26168 void *argp1 = 0 ;
26169 int res1 = 0 ;
26170 void *argp2 = 0 ;
26171 int res2 = 0 ;
26172
26173 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26175 if (!SWIG_IsOK(res1)) {
26176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26177 }
26178 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26179 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26180 if (!SWIG_IsOK(res2)) {
26181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26182 }
26183 if (!argp2) {
26184 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26185 }
26186 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26187 {
26188 PyThreadState* __tstate = wxPyBeginAllowThreads();
26189 {
26190 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26191 result = (wxDateTime *) &_result_ref;
26192 }
26193 wxPyEndAllowThreads(__tstate);
26194 if (PyErr_Occurred()) SWIG_fail;
26195 }
26196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26197 return resultobj;
26198 fail:
26199 return NULL;
26200 }
26201
26202
26203 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26204 int argc;
26205 PyObject *argv[3];
26206
26207 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26208 --argc;
26209 if (argc == 2) {
26210 int _v = 0;
26211 {
26212 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26213 _v = SWIG_CheckState(res);
26214 }
26215 if (!_v) goto check_1;
26216 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26217 }
26218 check_1:
26219
26220 if (argc == 2) {
26221 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26222 }
26223
26224 fail:
26225 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26226 return NULL;
26227 }
26228
26229
26230 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26231 PyObject *resultobj = 0;
26232 wxDateTime *arg1 = (wxDateTime *) 0 ;
26233 wxTimeSpan *arg2 = 0 ;
26234 wxDateTime *result = 0 ;
26235 void *argp1 = 0 ;
26236 int res1 = 0 ;
26237 void *argp2 = 0 ;
26238 int res2 = 0 ;
26239
26240 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26242 if (!SWIG_IsOK(res1)) {
26243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26244 }
26245 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26246 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26247 if (!SWIG_IsOK(res2)) {
26248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26249 }
26250 if (!argp2) {
26251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26252 }
26253 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26254 {
26255 PyThreadState* __tstate = wxPyBeginAllowThreads();
26256 {
26257 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26258 result = (wxDateTime *) &_result_ref;
26259 }
26260 wxPyEndAllowThreads(__tstate);
26261 if (PyErr_Occurred()) SWIG_fail;
26262 }
26263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26264 return resultobj;
26265 fail:
26266 return NULL;
26267 }
26268
26269
26270 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26271 PyObject *resultobj = 0;
26272 wxDateTime *arg1 = (wxDateTime *) 0 ;
26273 wxDateSpan *arg2 = 0 ;
26274 wxDateTime *result = 0 ;
26275 void *argp1 = 0 ;
26276 int res1 = 0 ;
26277 void *argp2 = 0 ;
26278 int res2 = 0 ;
26279
26280 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26282 if (!SWIG_IsOK(res1)) {
26283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26284 }
26285 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26286 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26287 if (!SWIG_IsOK(res2)) {
26288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26289 }
26290 if (!argp2) {
26291 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26292 }
26293 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26294 {
26295 PyThreadState* __tstate = wxPyBeginAllowThreads();
26296 {
26297 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26298 result = (wxDateTime *) &_result_ref;
26299 }
26300 wxPyEndAllowThreads(__tstate);
26301 if (PyErr_Occurred()) SWIG_fail;
26302 }
26303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26304 return resultobj;
26305 fail:
26306 return NULL;
26307 }
26308
26309
26310 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26311 int argc;
26312 PyObject *argv[3];
26313
26314 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26315 --argc;
26316 if (argc == 2) {
26317 int _v = 0;
26318 {
26319 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26320 _v = SWIG_CheckState(res);
26321 }
26322 if (!_v) goto check_1;
26323 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26324 }
26325 check_1:
26326
26327 if (argc == 2) {
26328 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26329 }
26330
26331 fail:
26332 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26333 return NULL;
26334 }
26335
26336
26337 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26338 PyObject *resultobj = 0;
26339 wxDateTime *arg1 = (wxDateTime *) 0 ;
26340 wxTimeSpan *arg2 = 0 ;
26341 wxDateTime result;
26342 void *argp1 = 0 ;
26343 int res1 = 0 ;
26344 void *argp2 = 0 ;
26345 int res2 = 0 ;
26346
26347 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26349 if (!SWIG_IsOK(res1)) {
26350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26351 }
26352 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26353 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26354 if (!SWIG_IsOK(res2)) {
26355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26356 }
26357 if (!argp2) {
26358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26359 }
26360 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26361 {
26362 PyThreadState* __tstate = wxPyBeginAllowThreads();
26363 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26364 wxPyEndAllowThreads(__tstate);
26365 if (PyErr_Occurred()) SWIG_fail;
26366 }
26367 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26368 return resultobj;
26369 fail:
26370 return NULL;
26371 }
26372
26373
26374 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26375 PyObject *resultobj = 0;
26376 wxDateTime *arg1 = (wxDateTime *) 0 ;
26377 wxDateSpan *arg2 = 0 ;
26378 wxDateTime result;
26379 void *argp1 = 0 ;
26380 int res1 = 0 ;
26381 void *argp2 = 0 ;
26382 int res2 = 0 ;
26383
26384 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26386 if (!SWIG_IsOK(res1)) {
26387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26388 }
26389 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26390 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26391 if (!SWIG_IsOK(res2)) {
26392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26393 }
26394 if (!argp2) {
26395 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26396 }
26397 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26398 {
26399 PyThreadState* __tstate = wxPyBeginAllowThreads();
26400 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26401 wxPyEndAllowThreads(__tstate);
26402 if (PyErr_Occurred()) SWIG_fail;
26403 }
26404 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26405 return resultobj;
26406 fail:
26407 return NULL;
26408 }
26409
26410
26411 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26412 int argc;
26413 PyObject *argv[3];
26414
26415 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26416 --argc;
26417 if (argc == 2) {
26418 int _v = 0;
26419 {
26420 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26421 _v = SWIG_CheckState(res);
26422 }
26423 if (!_v) goto check_1;
26424 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26425 }
26426 check_1:
26427
26428 if (argc == 2) {
26429 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26430 }
26431
26432 fail:
26433 Py_INCREF(Py_NotImplemented);
26434 return Py_NotImplemented;
26435 }
26436
26437
26438 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26439 PyObject *resultobj = 0;
26440 wxDateTime *arg1 = (wxDateTime *) 0 ;
26441 wxDateTime *arg2 = 0 ;
26442 wxTimeSpan result;
26443 void *argp1 = 0 ;
26444 int res1 = 0 ;
26445 void *argp2 = 0 ;
26446 int res2 = 0 ;
26447
26448 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26450 if (!SWIG_IsOK(res1)) {
26451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26452 }
26453 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26454 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26455 if (!SWIG_IsOK(res2)) {
26456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26457 }
26458 if (!argp2) {
26459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26460 }
26461 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26462 {
26463 PyThreadState* __tstate = wxPyBeginAllowThreads();
26464 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26465 wxPyEndAllowThreads(__tstate);
26466 if (PyErr_Occurred()) SWIG_fail;
26467 }
26468 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26469 return resultobj;
26470 fail:
26471 return NULL;
26472 }
26473
26474
26475 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26476 PyObject *resultobj = 0;
26477 wxDateTime *arg1 = (wxDateTime *) 0 ;
26478 wxTimeSpan *arg2 = 0 ;
26479 wxDateTime result;
26480 void *argp1 = 0 ;
26481 int res1 = 0 ;
26482 void *argp2 = 0 ;
26483 int res2 = 0 ;
26484
26485 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26487 if (!SWIG_IsOK(res1)) {
26488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26489 }
26490 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26491 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26492 if (!SWIG_IsOK(res2)) {
26493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26494 }
26495 if (!argp2) {
26496 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26497 }
26498 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26499 {
26500 PyThreadState* __tstate = wxPyBeginAllowThreads();
26501 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26502 wxPyEndAllowThreads(__tstate);
26503 if (PyErr_Occurred()) SWIG_fail;
26504 }
26505 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26506 return resultobj;
26507 fail:
26508 return NULL;
26509 }
26510
26511
26512 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26513 PyObject *resultobj = 0;
26514 wxDateTime *arg1 = (wxDateTime *) 0 ;
26515 wxDateSpan *arg2 = 0 ;
26516 wxDateTime result;
26517 void *argp1 = 0 ;
26518 int res1 = 0 ;
26519 void *argp2 = 0 ;
26520 int res2 = 0 ;
26521
26522 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26524 if (!SWIG_IsOK(res1)) {
26525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26526 }
26527 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26528 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26529 if (!SWIG_IsOK(res2)) {
26530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26531 }
26532 if (!argp2) {
26533 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26534 }
26535 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26536 {
26537 PyThreadState* __tstate = wxPyBeginAllowThreads();
26538 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26539 wxPyEndAllowThreads(__tstate);
26540 if (PyErr_Occurred()) SWIG_fail;
26541 }
26542 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26543 return resultobj;
26544 fail:
26545 return NULL;
26546 }
26547
26548
26549 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26550 int argc;
26551 PyObject *argv[3];
26552
26553 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26554 --argc;
26555 if (argc == 2) {
26556 int _v = 0;
26557 {
26558 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26559 _v = SWIG_CheckState(res);
26560 }
26561 if (!_v) goto check_1;
26562 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26563 }
26564 check_1:
26565
26566 if (argc == 2) {
26567 int _v = 0;
26568 {
26569 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26570 _v = SWIG_CheckState(res);
26571 }
26572 if (!_v) goto check_2;
26573 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26574 }
26575 check_2:
26576
26577 if (argc == 2) {
26578 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26579 }
26580
26581 fail:
26582 Py_INCREF(Py_NotImplemented);
26583 return Py_NotImplemented;
26584 }
26585
26586
26587 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26588 PyObject *resultobj = 0;
26589 wxDateTime *arg1 = (wxDateTime *) 0 ;
26590 wxDateTime *arg2 = (wxDateTime *) 0 ;
26591 bool result;
26592 void *argp1 = 0 ;
26593 int res1 = 0 ;
26594 void *argp2 = 0 ;
26595 int res2 = 0 ;
26596 PyObject * obj0 = 0 ;
26597 PyObject * obj1 = 0 ;
26598 char * kwnames[] = {
26599 (char *) "self",(char *) "other", NULL
26600 };
26601
26602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26604 if (!SWIG_IsOK(res1)) {
26605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26606 }
26607 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26609 if (!SWIG_IsOK(res2)) {
26610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26611 }
26612 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26613 {
26614 PyThreadState* __tstate = wxPyBeginAllowThreads();
26615 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26616 wxPyEndAllowThreads(__tstate);
26617 if (PyErr_Occurred()) SWIG_fail;
26618 }
26619 {
26620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26621 }
26622 return resultobj;
26623 fail:
26624 return NULL;
26625 }
26626
26627
26628 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26629 PyObject *resultobj = 0;
26630 wxDateTime *arg1 = (wxDateTime *) 0 ;
26631 wxDateTime *arg2 = (wxDateTime *) 0 ;
26632 bool result;
26633 void *argp1 = 0 ;
26634 int res1 = 0 ;
26635 void *argp2 = 0 ;
26636 int res2 = 0 ;
26637 PyObject * obj0 = 0 ;
26638 PyObject * obj1 = 0 ;
26639 char * kwnames[] = {
26640 (char *) "self",(char *) "other", NULL
26641 };
26642
26643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26645 if (!SWIG_IsOK(res1)) {
26646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26647 }
26648 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26649 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26650 if (!SWIG_IsOK(res2)) {
26651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26652 }
26653 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26654 {
26655 PyThreadState* __tstate = wxPyBeginAllowThreads();
26656 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26657 wxPyEndAllowThreads(__tstate);
26658 if (PyErr_Occurred()) SWIG_fail;
26659 }
26660 {
26661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26662 }
26663 return resultobj;
26664 fail:
26665 return NULL;
26666 }
26667
26668
26669 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26670 PyObject *resultobj = 0;
26671 wxDateTime *arg1 = (wxDateTime *) 0 ;
26672 wxDateTime *arg2 = (wxDateTime *) 0 ;
26673 bool result;
26674 void *argp1 = 0 ;
26675 int res1 = 0 ;
26676 void *argp2 = 0 ;
26677 int res2 = 0 ;
26678 PyObject * obj0 = 0 ;
26679 PyObject * obj1 = 0 ;
26680 char * kwnames[] = {
26681 (char *) "self",(char *) "other", NULL
26682 };
26683
26684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26686 if (!SWIG_IsOK(res1)) {
26687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26688 }
26689 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26691 if (!SWIG_IsOK(res2)) {
26692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26693 }
26694 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26695 {
26696 PyThreadState* __tstate = wxPyBeginAllowThreads();
26697 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26698 wxPyEndAllowThreads(__tstate);
26699 if (PyErr_Occurred()) SWIG_fail;
26700 }
26701 {
26702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26703 }
26704 return resultobj;
26705 fail:
26706 return NULL;
26707 }
26708
26709
26710 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26711 PyObject *resultobj = 0;
26712 wxDateTime *arg1 = (wxDateTime *) 0 ;
26713 wxDateTime *arg2 = (wxDateTime *) 0 ;
26714 bool result;
26715 void *argp1 = 0 ;
26716 int res1 = 0 ;
26717 void *argp2 = 0 ;
26718 int res2 = 0 ;
26719 PyObject * obj0 = 0 ;
26720 PyObject * obj1 = 0 ;
26721 char * kwnames[] = {
26722 (char *) "self",(char *) "other", NULL
26723 };
26724
26725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26727 if (!SWIG_IsOK(res1)) {
26728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26729 }
26730 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26731 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26732 if (!SWIG_IsOK(res2)) {
26733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26734 }
26735 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26736 {
26737 PyThreadState* __tstate = wxPyBeginAllowThreads();
26738 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26739 wxPyEndAllowThreads(__tstate);
26740 if (PyErr_Occurred()) SWIG_fail;
26741 }
26742 {
26743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26744 }
26745 return resultobj;
26746 fail:
26747 return NULL;
26748 }
26749
26750
26751 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26752 PyObject *resultobj = 0;
26753 wxDateTime *arg1 = (wxDateTime *) 0 ;
26754 wxDateTime *arg2 = (wxDateTime *) 0 ;
26755 bool result;
26756 void *argp1 = 0 ;
26757 int res1 = 0 ;
26758 void *argp2 = 0 ;
26759 int res2 = 0 ;
26760 PyObject * obj0 = 0 ;
26761 PyObject * obj1 = 0 ;
26762 char * kwnames[] = {
26763 (char *) "self",(char *) "other", NULL
26764 };
26765
26766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26768 if (!SWIG_IsOK(res1)) {
26769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26770 }
26771 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26773 if (!SWIG_IsOK(res2)) {
26774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26775 }
26776 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26780 wxPyEndAllowThreads(__tstate);
26781 if (PyErr_Occurred()) SWIG_fail;
26782 }
26783 {
26784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26785 }
26786 return resultobj;
26787 fail:
26788 return NULL;
26789 }
26790
26791
26792 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26793 PyObject *resultobj = 0;
26794 wxDateTime *arg1 = (wxDateTime *) 0 ;
26795 wxDateTime *arg2 = (wxDateTime *) 0 ;
26796 bool result;
26797 void *argp1 = 0 ;
26798 int res1 = 0 ;
26799 void *argp2 = 0 ;
26800 int res2 = 0 ;
26801 PyObject * obj0 = 0 ;
26802 PyObject * obj1 = 0 ;
26803 char * kwnames[] = {
26804 (char *) "self",(char *) "other", NULL
26805 };
26806
26807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26809 if (!SWIG_IsOK(res1)) {
26810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26811 }
26812 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26814 if (!SWIG_IsOK(res2)) {
26815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26816 }
26817 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26818 {
26819 PyThreadState* __tstate = wxPyBeginAllowThreads();
26820 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26821 wxPyEndAllowThreads(__tstate);
26822 if (PyErr_Occurred()) SWIG_fail;
26823 }
26824 {
26825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26826 }
26827 return resultobj;
26828 fail:
26829 return NULL;
26830 }
26831
26832
26833 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26834 PyObject *resultobj = 0;
26835 wxDateTime *arg1 = (wxDateTime *) 0 ;
26836 wxString *arg2 = 0 ;
26837 int result;
26838 void *argp1 = 0 ;
26839 int res1 = 0 ;
26840 bool temp2 = false ;
26841 PyObject * obj0 = 0 ;
26842 PyObject * obj1 = 0 ;
26843 char * kwnames[] = {
26844 (char *) "self",(char *) "date", NULL
26845 };
26846
26847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
26848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26849 if (!SWIG_IsOK(res1)) {
26850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26851 }
26852 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26853 {
26854 arg2 = wxString_in_helper(obj1);
26855 if (arg2 == NULL) SWIG_fail;
26856 temp2 = true;
26857 }
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 resultobj = SWIG_From_int(static_cast< int >(result));
26865 {
26866 if (temp2)
26867 delete arg2;
26868 }
26869 return resultobj;
26870 fail:
26871 {
26872 if (temp2)
26873 delete arg2;
26874 }
26875 return NULL;
26876 }
26877
26878
26879 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26880 PyObject *resultobj = 0;
26881 wxDateTime *arg1 = (wxDateTime *) 0 ;
26882 wxString *arg2 = 0 ;
26883 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26884 wxString *arg3 = (wxString *) &arg3_defvalue ;
26885 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26886 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26887 int result;
26888 void *argp1 = 0 ;
26889 int res1 = 0 ;
26890 bool temp2 = false ;
26891 bool temp3 = false ;
26892 void *argp4 = 0 ;
26893 int res4 = 0 ;
26894 PyObject * obj0 = 0 ;
26895 PyObject * obj1 = 0 ;
26896 PyObject * obj2 = 0 ;
26897 PyObject * obj3 = 0 ;
26898 char * kwnames[] = {
26899 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26900 };
26901
26902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26904 if (!SWIG_IsOK(res1)) {
26905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26906 }
26907 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26908 {
26909 arg2 = wxString_in_helper(obj1);
26910 if (arg2 == NULL) SWIG_fail;
26911 temp2 = true;
26912 }
26913 if (obj2) {
26914 {
26915 arg3 = wxString_in_helper(obj2);
26916 if (arg3 == NULL) SWIG_fail;
26917 temp3 = true;
26918 }
26919 }
26920 if (obj3) {
26921 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26922 if (!SWIG_IsOK(res4)) {
26923 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26924 }
26925 if (!argp4) {
26926 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26927 }
26928 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26929 }
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 resultobj = SWIG_From_int(static_cast< int >(result));
26937 {
26938 if (temp2)
26939 delete arg2;
26940 }
26941 {
26942 if (temp3)
26943 delete arg3;
26944 }
26945 return resultobj;
26946 fail:
26947 {
26948 if (temp2)
26949 delete arg2;
26950 }
26951 {
26952 if (temp3)
26953 delete arg3;
26954 }
26955 return NULL;
26956 }
26957
26958
26959 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj = 0;
26961 wxDateTime *arg1 = (wxDateTime *) 0 ;
26962 wxString *arg2 = 0 ;
26963 int result;
26964 void *argp1 = 0 ;
26965 int res1 = 0 ;
26966 bool temp2 = false ;
26967 PyObject * obj0 = 0 ;
26968 PyObject * obj1 = 0 ;
26969 char * kwnames[] = {
26970 (char *) "self",(char *) "datetime", NULL
26971 };
26972
26973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26975 if (!SWIG_IsOK(res1)) {
26976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26977 }
26978 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26979 {
26980 arg2 = wxString_in_helper(obj1);
26981 if (arg2 == NULL) SWIG_fail;
26982 temp2 = true;
26983 }
26984 {
26985 PyThreadState* __tstate = wxPyBeginAllowThreads();
26986 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26987 wxPyEndAllowThreads(__tstate);
26988 if (PyErr_Occurred()) SWIG_fail;
26989 }
26990 resultobj = SWIG_From_int(static_cast< int >(result));
26991 {
26992 if (temp2)
26993 delete arg2;
26994 }
26995 return resultobj;
26996 fail:
26997 {
26998 if (temp2)
26999 delete arg2;
27000 }
27001 return NULL;
27002 }
27003
27004
27005 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27006 PyObject *resultobj = 0;
27007 wxDateTime *arg1 = (wxDateTime *) 0 ;
27008 wxString *arg2 = 0 ;
27009 int result;
27010 void *argp1 = 0 ;
27011 int res1 = 0 ;
27012 bool temp2 = false ;
27013 PyObject * obj0 = 0 ;
27014 PyObject * obj1 = 0 ;
27015 char * kwnames[] = {
27016 (char *) "self",(char *) "date", NULL
27017 };
27018
27019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27021 if (!SWIG_IsOK(res1)) {
27022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27023 }
27024 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27025 {
27026 arg2 = wxString_in_helper(obj1);
27027 if (arg2 == NULL) SWIG_fail;
27028 temp2 = true;
27029 }
27030 {
27031 PyThreadState* __tstate = wxPyBeginAllowThreads();
27032 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27033 wxPyEndAllowThreads(__tstate);
27034 if (PyErr_Occurred()) SWIG_fail;
27035 }
27036 resultobj = SWIG_From_int(static_cast< int >(result));
27037 {
27038 if (temp2)
27039 delete arg2;
27040 }
27041 return resultobj;
27042 fail:
27043 {
27044 if (temp2)
27045 delete arg2;
27046 }
27047 return NULL;
27048 }
27049
27050
27051 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27052 PyObject *resultobj = 0;
27053 wxDateTime *arg1 = (wxDateTime *) 0 ;
27054 wxString *arg2 = 0 ;
27055 int result;
27056 void *argp1 = 0 ;
27057 int res1 = 0 ;
27058 bool temp2 = false ;
27059 PyObject * obj0 = 0 ;
27060 PyObject * obj1 = 0 ;
27061 char * kwnames[] = {
27062 (char *) "self",(char *) "time", NULL
27063 };
27064
27065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27067 if (!SWIG_IsOK(res1)) {
27068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27069 }
27070 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27071 {
27072 arg2 = wxString_in_helper(obj1);
27073 if (arg2 == NULL) SWIG_fail;
27074 temp2 = true;
27075 }
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27079 wxPyEndAllowThreads(__tstate);
27080 if (PyErr_Occurred()) SWIG_fail;
27081 }
27082 resultobj = SWIG_From_int(static_cast< int >(result));
27083 {
27084 if (temp2)
27085 delete arg2;
27086 }
27087 return resultobj;
27088 fail:
27089 {
27090 if (temp2)
27091 delete arg2;
27092 }
27093 return NULL;
27094 }
27095
27096
27097 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27098 PyObject *resultobj = 0;
27099 wxDateTime *arg1 = (wxDateTime *) 0 ;
27100 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27101 wxString *arg2 = (wxString *) &arg2_defvalue ;
27102 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27103 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27104 wxString result;
27105 void *argp1 = 0 ;
27106 int res1 = 0 ;
27107 bool temp2 = false ;
27108 bool temp3 = false ;
27109 PyObject * obj0 = 0 ;
27110 PyObject * obj1 = 0 ;
27111 PyObject * obj2 = 0 ;
27112 char * kwnames[] = {
27113 (char *) "self",(char *) "format",(char *) "tz", NULL
27114 };
27115
27116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27118 if (!SWIG_IsOK(res1)) {
27119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27120 }
27121 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27122 if (obj1) {
27123 {
27124 arg2 = wxString_in_helper(obj1);
27125 if (arg2 == NULL) SWIG_fail;
27126 temp2 = true;
27127 }
27128 }
27129 if (obj2) {
27130 {
27131 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27132 temp3 = true;
27133 }
27134 }
27135 {
27136 PyThreadState* __tstate = wxPyBeginAllowThreads();
27137 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27138 wxPyEndAllowThreads(__tstate);
27139 if (PyErr_Occurred()) SWIG_fail;
27140 }
27141 {
27142 #if wxUSE_UNICODE
27143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27144 #else
27145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27146 #endif
27147 }
27148 {
27149 if (temp2)
27150 delete arg2;
27151 }
27152 {
27153 if (temp3) delete arg3;
27154 }
27155 return resultobj;
27156 fail:
27157 {
27158 if (temp2)
27159 delete arg2;
27160 }
27161 {
27162 if (temp3) delete arg3;
27163 }
27164 return NULL;
27165 }
27166
27167
27168 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27169 PyObject *resultobj = 0;
27170 wxDateTime *arg1 = (wxDateTime *) 0 ;
27171 wxString result;
27172 void *argp1 = 0 ;
27173 int res1 = 0 ;
27174 PyObject *swig_obj[1] ;
27175
27176 if (!args) SWIG_fail;
27177 swig_obj[0] = args;
27178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27179 if (!SWIG_IsOK(res1)) {
27180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27181 }
27182 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27183 {
27184 PyThreadState* __tstate = wxPyBeginAllowThreads();
27185 result = ((wxDateTime const *)arg1)->FormatDate();
27186 wxPyEndAllowThreads(__tstate);
27187 if (PyErr_Occurred()) SWIG_fail;
27188 }
27189 {
27190 #if wxUSE_UNICODE
27191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27192 #else
27193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27194 #endif
27195 }
27196 return resultobj;
27197 fail:
27198 return NULL;
27199 }
27200
27201
27202 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27203 PyObject *resultobj = 0;
27204 wxDateTime *arg1 = (wxDateTime *) 0 ;
27205 wxString result;
27206 void *argp1 = 0 ;
27207 int res1 = 0 ;
27208 PyObject *swig_obj[1] ;
27209
27210 if (!args) SWIG_fail;
27211 swig_obj[0] = args;
27212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27213 if (!SWIG_IsOK(res1)) {
27214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27215 }
27216 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27217 {
27218 PyThreadState* __tstate = wxPyBeginAllowThreads();
27219 result = ((wxDateTime const *)arg1)->FormatTime();
27220 wxPyEndAllowThreads(__tstate);
27221 if (PyErr_Occurred()) SWIG_fail;
27222 }
27223 {
27224 #if wxUSE_UNICODE
27225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27226 #else
27227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27228 #endif
27229 }
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27237 PyObject *resultobj = 0;
27238 wxDateTime *arg1 = (wxDateTime *) 0 ;
27239 wxString result;
27240 void *argp1 = 0 ;
27241 int res1 = 0 ;
27242 PyObject *swig_obj[1] ;
27243
27244 if (!args) SWIG_fail;
27245 swig_obj[0] = args;
27246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27247 if (!SWIG_IsOK(res1)) {
27248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27249 }
27250 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 result = ((wxDateTime const *)arg1)->FormatISODate();
27254 wxPyEndAllowThreads(__tstate);
27255 if (PyErr_Occurred()) SWIG_fail;
27256 }
27257 {
27258 #if wxUSE_UNICODE
27259 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27260 #else
27261 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27262 #endif
27263 }
27264 return resultobj;
27265 fail:
27266 return NULL;
27267 }
27268
27269
27270 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27271 PyObject *resultobj = 0;
27272 wxDateTime *arg1 = (wxDateTime *) 0 ;
27273 wxString result;
27274 void *argp1 = 0 ;
27275 int res1 = 0 ;
27276 PyObject *swig_obj[1] ;
27277
27278 if (!args) SWIG_fail;
27279 swig_obj[0] = args;
27280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27281 if (!SWIG_IsOK(res1)) {
27282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27283 }
27284 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27285 {
27286 PyThreadState* __tstate = wxPyBeginAllowThreads();
27287 result = ((wxDateTime const *)arg1)->FormatISOTime();
27288 wxPyEndAllowThreads(__tstate);
27289 if (PyErr_Occurred()) SWIG_fail;
27290 }
27291 {
27292 #if wxUSE_UNICODE
27293 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27294 #else
27295 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27296 #endif
27297 }
27298 return resultobj;
27299 fail:
27300 return NULL;
27301 }
27302
27303
27304 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27305 PyObject *obj;
27306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27307 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27308 return SWIG_Py_Void();
27309 }
27310
27311 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27312 return SWIG_Python_InitShadowInstance(args);
27313 }
27314
27315 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27316 PyObject *resultobj = 0;
27317 long arg1 ;
27318 wxTimeSpan result;
27319 long val1 ;
27320 int ecode1 = 0 ;
27321 PyObject * obj0 = 0 ;
27322 char * kwnames[] = {
27323 (char *) "ms", NULL
27324 };
27325
27326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27327 ecode1 = SWIG_AsVal_long(obj0, &val1);
27328 if (!SWIG_IsOK(ecode1)) {
27329 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27330 }
27331 arg1 = static_cast< long >(val1);
27332 {
27333 PyThreadState* __tstate = wxPyBeginAllowThreads();
27334 result = wxTimeSpan::Milliseconds(arg1);
27335 wxPyEndAllowThreads(__tstate);
27336 if (PyErr_Occurred()) SWIG_fail;
27337 }
27338 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27339 return resultobj;
27340 fail:
27341 return NULL;
27342 }
27343
27344
27345 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27346 PyObject *resultobj = 0;
27347 wxTimeSpan result;
27348
27349 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27350 {
27351 PyThreadState* __tstate = wxPyBeginAllowThreads();
27352 result = wxTimeSpan::Millisecond();
27353 wxPyEndAllowThreads(__tstate);
27354 if (PyErr_Occurred()) SWIG_fail;
27355 }
27356 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27357 return resultobj;
27358 fail:
27359 return NULL;
27360 }
27361
27362
27363 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27364 PyObject *resultobj = 0;
27365 long arg1 ;
27366 wxTimeSpan result;
27367 long val1 ;
27368 int ecode1 = 0 ;
27369 PyObject * obj0 = 0 ;
27370 char * kwnames[] = {
27371 (char *) "sec", NULL
27372 };
27373
27374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27375 ecode1 = SWIG_AsVal_long(obj0, &val1);
27376 if (!SWIG_IsOK(ecode1)) {
27377 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27378 }
27379 arg1 = static_cast< long >(val1);
27380 {
27381 PyThreadState* __tstate = wxPyBeginAllowThreads();
27382 result = wxTimeSpan::Seconds(arg1);
27383 wxPyEndAllowThreads(__tstate);
27384 if (PyErr_Occurred()) SWIG_fail;
27385 }
27386 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27387 return resultobj;
27388 fail:
27389 return NULL;
27390 }
27391
27392
27393 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27394 PyObject *resultobj = 0;
27395 wxTimeSpan result;
27396
27397 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27398 {
27399 PyThreadState* __tstate = wxPyBeginAllowThreads();
27400 result = wxTimeSpan::Second();
27401 wxPyEndAllowThreads(__tstate);
27402 if (PyErr_Occurred()) SWIG_fail;
27403 }
27404 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27405 return resultobj;
27406 fail:
27407 return NULL;
27408 }
27409
27410
27411 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27412 PyObject *resultobj = 0;
27413 long arg1 ;
27414 wxTimeSpan result;
27415 long val1 ;
27416 int ecode1 = 0 ;
27417 PyObject * obj0 = 0 ;
27418 char * kwnames[] = {
27419 (char *) "min", NULL
27420 };
27421
27422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27423 ecode1 = SWIG_AsVal_long(obj0, &val1);
27424 if (!SWIG_IsOK(ecode1)) {
27425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27426 }
27427 arg1 = static_cast< long >(val1);
27428 {
27429 PyThreadState* __tstate = wxPyBeginAllowThreads();
27430 result = wxTimeSpan::Minutes(arg1);
27431 wxPyEndAllowThreads(__tstate);
27432 if (PyErr_Occurred()) SWIG_fail;
27433 }
27434 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27435 return resultobj;
27436 fail:
27437 return NULL;
27438 }
27439
27440
27441 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27442 PyObject *resultobj = 0;
27443 wxTimeSpan result;
27444
27445 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27446 {
27447 PyThreadState* __tstate = wxPyBeginAllowThreads();
27448 result = wxTimeSpan::Minute();
27449 wxPyEndAllowThreads(__tstate);
27450 if (PyErr_Occurred()) SWIG_fail;
27451 }
27452 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27453 return resultobj;
27454 fail:
27455 return NULL;
27456 }
27457
27458
27459 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27460 PyObject *resultobj = 0;
27461 long arg1 ;
27462 wxTimeSpan result;
27463 long val1 ;
27464 int ecode1 = 0 ;
27465 PyObject * obj0 = 0 ;
27466 char * kwnames[] = {
27467 (char *) "hours", NULL
27468 };
27469
27470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27471 ecode1 = SWIG_AsVal_long(obj0, &val1);
27472 if (!SWIG_IsOK(ecode1)) {
27473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27474 }
27475 arg1 = static_cast< long >(val1);
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 result = wxTimeSpan::Hours(arg1);
27479 wxPyEndAllowThreads(__tstate);
27480 if (PyErr_Occurred()) SWIG_fail;
27481 }
27482 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27483 return resultobj;
27484 fail:
27485 return NULL;
27486 }
27487
27488
27489 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27490 PyObject *resultobj = 0;
27491 wxTimeSpan result;
27492
27493 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27494 {
27495 PyThreadState* __tstate = wxPyBeginAllowThreads();
27496 result = wxTimeSpan::Hour();
27497 wxPyEndAllowThreads(__tstate);
27498 if (PyErr_Occurred()) SWIG_fail;
27499 }
27500 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27501 return resultobj;
27502 fail:
27503 return NULL;
27504 }
27505
27506
27507 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27508 PyObject *resultobj = 0;
27509 long arg1 ;
27510 wxTimeSpan result;
27511 long val1 ;
27512 int ecode1 = 0 ;
27513 PyObject * obj0 = 0 ;
27514 char * kwnames[] = {
27515 (char *) "days", NULL
27516 };
27517
27518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27519 ecode1 = SWIG_AsVal_long(obj0, &val1);
27520 if (!SWIG_IsOK(ecode1)) {
27521 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27522 }
27523 arg1 = static_cast< long >(val1);
27524 {
27525 PyThreadState* __tstate = wxPyBeginAllowThreads();
27526 result = wxTimeSpan::Days(arg1);
27527 wxPyEndAllowThreads(__tstate);
27528 if (PyErr_Occurred()) SWIG_fail;
27529 }
27530 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27531 return resultobj;
27532 fail:
27533 return NULL;
27534 }
27535
27536
27537 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27538 PyObject *resultobj = 0;
27539 wxTimeSpan result;
27540
27541 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27542 {
27543 PyThreadState* __tstate = wxPyBeginAllowThreads();
27544 result = wxTimeSpan::Day();
27545 wxPyEndAllowThreads(__tstate);
27546 if (PyErr_Occurred()) SWIG_fail;
27547 }
27548 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27549 return resultobj;
27550 fail:
27551 return NULL;
27552 }
27553
27554
27555 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27556 PyObject *resultobj = 0;
27557 long arg1 ;
27558 wxTimeSpan result;
27559 long val1 ;
27560 int ecode1 = 0 ;
27561 PyObject * obj0 = 0 ;
27562 char * kwnames[] = {
27563 (char *) "days", NULL
27564 };
27565
27566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27567 ecode1 = SWIG_AsVal_long(obj0, &val1);
27568 if (!SWIG_IsOK(ecode1)) {
27569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27570 }
27571 arg1 = static_cast< long >(val1);
27572 {
27573 PyThreadState* __tstate = wxPyBeginAllowThreads();
27574 result = wxTimeSpan::Weeks(arg1);
27575 wxPyEndAllowThreads(__tstate);
27576 if (PyErr_Occurred()) SWIG_fail;
27577 }
27578 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27586 PyObject *resultobj = 0;
27587 wxTimeSpan result;
27588
27589 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 result = wxTimeSpan::Week();
27593 wxPyEndAllowThreads(__tstate);
27594 if (PyErr_Occurred()) SWIG_fail;
27595 }
27596 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27597 return resultobj;
27598 fail:
27599 return NULL;
27600 }
27601
27602
27603 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27604 PyObject *resultobj = 0;
27605 long arg1 = (long) 0 ;
27606 long arg2 = (long) 0 ;
27607 long arg3 = (long) 0 ;
27608 long arg4 = (long) 0 ;
27609 wxTimeSpan *result = 0 ;
27610 long val1 ;
27611 int ecode1 = 0 ;
27612 long val2 ;
27613 int ecode2 = 0 ;
27614 long val3 ;
27615 int ecode3 = 0 ;
27616 long val4 ;
27617 int ecode4 = 0 ;
27618 PyObject * obj0 = 0 ;
27619 PyObject * obj1 = 0 ;
27620 PyObject * obj2 = 0 ;
27621 PyObject * obj3 = 0 ;
27622 char * kwnames[] = {
27623 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27624 };
27625
27626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27627 if (obj0) {
27628 ecode1 = SWIG_AsVal_long(obj0, &val1);
27629 if (!SWIG_IsOK(ecode1)) {
27630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27631 }
27632 arg1 = static_cast< long >(val1);
27633 }
27634 if (obj1) {
27635 ecode2 = SWIG_AsVal_long(obj1, &val2);
27636 if (!SWIG_IsOK(ecode2)) {
27637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27638 }
27639 arg2 = static_cast< long >(val2);
27640 }
27641 if (obj2) {
27642 ecode3 = SWIG_AsVal_long(obj2, &val3);
27643 if (!SWIG_IsOK(ecode3)) {
27644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27645 }
27646 arg3 = static_cast< long >(val3);
27647 }
27648 if (obj3) {
27649 ecode4 = SWIG_AsVal_long(obj3, &val4);
27650 if (!SWIG_IsOK(ecode4)) {
27651 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27652 }
27653 arg4 = static_cast< long >(val4);
27654 }
27655 {
27656 PyThreadState* __tstate = wxPyBeginAllowThreads();
27657 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27658 wxPyEndAllowThreads(__tstate);
27659 if (PyErr_Occurred()) SWIG_fail;
27660 }
27661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27662 return resultobj;
27663 fail:
27664 return NULL;
27665 }
27666
27667
27668 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27669 PyObject *resultobj = 0;
27670 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27671 void *argp1 = 0 ;
27672 int res1 = 0 ;
27673 PyObject *swig_obj[1] ;
27674
27675 if (!args) SWIG_fail;
27676 swig_obj[0] = args;
27677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27678 if (!SWIG_IsOK(res1)) {
27679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27680 }
27681 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27682 {
27683 PyThreadState* __tstate = wxPyBeginAllowThreads();
27684 delete arg1;
27685
27686 wxPyEndAllowThreads(__tstate);
27687 if (PyErr_Occurred()) SWIG_fail;
27688 }
27689 resultobj = SWIG_Py_Void();
27690 return resultobj;
27691 fail:
27692 return NULL;
27693 }
27694
27695
27696 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27697 PyObject *resultobj = 0;
27698 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27699 wxTimeSpan *arg2 = 0 ;
27700 wxTimeSpan *result = 0 ;
27701 void *argp1 = 0 ;
27702 int res1 = 0 ;
27703 void *argp2 = 0 ;
27704 int res2 = 0 ;
27705 PyObject * obj0 = 0 ;
27706 PyObject * obj1 = 0 ;
27707 char * kwnames[] = {
27708 (char *) "self",(char *) "diff", NULL
27709 };
27710
27711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27713 if (!SWIG_IsOK(res1)) {
27714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27715 }
27716 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27718 if (!SWIG_IsOK(res2)) {
27719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27720 }
27721 if (!argp2) {
27722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27723 }
27724 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27725 {
27726 PyThreadState* __tstate = wxPyBeginAllowThreads();
27727 {
27728 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27729 result = (wxTimeSpan *) &_result_ref;
27730 }
27731 wxPyEndAllowThreads(__tstate);
27732 if (PyErr_Occurred()) SWIG_fail;
27733 }
27734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27735 return resultobj;
27736 fail:
27737 return NULL;
27738 }
27739
27740
27741 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27742 PyObject *resultobj = 0;
27743 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27744 wxTimeSpan *arg2 = 0 ;
27745 wxTimeSpan *result = 0 ;
27746 void *argp1 = 0 ;
27747 int res1 = 0 ;
27748 void *argp2 = 0 ;
27749 int res2 = 0 ;
27750 PyObject * obj0 = 0 ;
27751 PyObject * obj1 = 0 ;
27752 char * kwnames[] = {
27753 (char *) "self",(char *) "diff", NULL
27754 };
27755
27756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27758 if (!SWIG_IsOK(res1)) {
27759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27760 }
27761 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27763 if (!SWIG_IsOK(res2)) {
27764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27765 }
27766 if (!argp2) {
27767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27768 }
27769 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27770 {
27771 PyThreadState* __tstate = wxPyBeginAllowThreads();
27772 {
27773 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27774 result = (wxTimeSpan *) &_result_ref;
27775 }
27776 wxPyEndAllowThreads(__tstate);
27777 if (PyErr_Occurred()) SWIG_fail;
27778 }
27779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27787 PyObject *resultobj = 0;
27788 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27789 int arg2 ;
27790 wxTimeSpan *result = 0 ;
27791 void *argp1 = 0 ;
27792 int res1 = 0 ;
27793 int val2 ;
27794 int ecode2 = 0 ;
27795 PyObject * obj0 = 0 ;
27796 PyObject * obj1 = 0 ;
27797 char * kwnames[] = {
27798 (char *) "self",(char *) "n", NULL
27799 };
27800
27801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27803 if (!SWIG_IsOK(res1)) {
27804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27805 }
27806 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27807 ecode2 = SWIG_AsVal_int(obj1, &val2);
27808 if (!SWIG_IsOK(ecode2)) {
27809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27810 }
27811 arg2 = static_cast< int >(val2);
27812 {
27813 PyThreadState* __tstate = wxPyBeginAllowThreads();
27814 {
27815 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27816 result = (wxTimeSpan *) &_result_ref;
27817 }
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27829 PyObject *resultobj = 0;
27830 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27831 wxTimeSpan *result = 0 ;
27832 void *argp1 = 0 ;
27833 int res1 = 0 ;
27834 PyObject *swig_obj[1] ;
27835
27836 if (!args) SWIG_fail;
27837 swig_obj[0] = args;
27838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27839 if (!SWIG_IsOK(res1)) {
27840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27841 }
27842 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27843 {
27844 PyThreadState* __tstate = wxPyBeginAllowThreads();
27845 {
27846 wxTimeSpan &_result_ref = (arg1)->Neg();
27847 result = (wxTimeSpan *) &_result_ref;
27848 }
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27853 return resultobj;
27854 fail:
27855 return NULL;
27856 }
27857
27858
27859 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27860 PyObject *resultobj = 0;
27861 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27862 wxTimeSpan result;
27863 void *argp1 = 0 ;
27864 int res1 = 0 ;
27865 PyObject *swig_obj[1] ;
27866
27867 if (!args) SWIG_fail;
27868 swig_obj[0] = args;
27869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27870 if (!SWIG_IsOK(res1)) {
27871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27872 }
27873 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27874 {
27875 PyThreadState* __tstate = wxPyBeginAllowThreads();
27876 result = ((wxTimeSpan const *)arg1)->Abs();
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27888 PyObject *resultobj = 0;
27889 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27890 wxTimeSpan *arg2 = 0 ;
27891 wxTimeSpan *result = 0 ;
27892 void *argp1 = 0 ;
27893 int res1 = 0 ;
27894 void *argp2 = 0 ;
27895 int res2 = 0 ;
27896 PyObject * obj0 = 0 ;
27897 PyObject * obj1 = 0 ;
27898 char * kwnames[] = {
27899 (char *) "self",(char *) "diff", NULL
27900 };
27901
27902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27904 if (!SWIG_IsOK(res1)) {
27905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27906 }
27907 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27908 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27909 if (!SWIG_IsOK(res2)) {
27910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27911 }
27912 if (!argp2) {
27913 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27914 }
27915 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 {
27919 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27920 result = (wxTimeSpan *) &_result_ref;
27921 }
27922 wxPyEndAllowThreads(__tstate);
27923 if (PyErr_Occurred()) SWIG_fail;
27924 }
27925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27926 return resultobj;
27927 fail:
27928 return NULL;
27929 }
27930
27931
27932 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27933 PyObject *resultobj = 0;
27934 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27935 wxTimeSpan *arg2 = 0 ;
27936 wxTimeSpan *result = 0 ;
27937 void *argp1 = 0 ;
27938 int res1 = 0 ;
27939 void *argp2 = 0 ;
27940 int res2 = 0 ;
27941 PyObject * obj0 = 0 ;
27942 PyObject * obj1 = 0 ;
27943 char * kwnames[] = {
27944 (char *) "self",(char *) "diff", NULL
27945 };
27946
27947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27949 if (!SWIG_IsOK(res1)) {
27950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27951 }
27952 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27954 if (!SWIG_IsOK(res2)) {
27955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27956 }
27957 if (!argp2) {
27958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27959 }
27960 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 {
27964 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27965 result = (wxTimeSpan *) &_result_ref;
27966 }
27967 wxPyEndAllowThreads(__tstate);
27968 if (PyErr_Occurred()) SWIG_fail;
27969 }
27970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27971 return resultobj;
27972 fail:
27973 return NULL;
27974 }
27975
27976
27977 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27978 PyObject *resultobj = 0;
27979 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27980 int arg2 ;
27981 wxTimeSpan *result = 0 ;
27982 void *argp1 = 0 ;
27983 int res1 = 0 ;
27984 int val2 ;
27985 int ecode2 = 0 ;
27986 PyObject * obj0 = 0 ;
27987 PyObject * obj1 = 0 ;
27988 char * kwnames[] = {
27989 (char *) "self",(char *) "n", NULL
27990 };
27991
27992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
27993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27994 if (!SWIG_IsOK(res1)) {
27995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27996 }
27997 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27998 ecode2 = SWIG_AsVal_int(obj1, &val2);
27999 if (!SWIG_IsOK(ecode2)) {
28000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28001 }
28002 arg2 = static_cast< int >(val2);
28003 {
28004 PyThreadState* __tstate = wxPyBeginAllowThreads();
28005 {
28006 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28007 result = (wxTimeSpan *) &_result_ref;
28008 }
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28013 return resultobj;
28014 fail:
28015 return NULL;
28016 }
28017
28018
28019 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28020 PyObject *resultobj = 0;
28021 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28022 wxTimeSpan *result = 0 ;
28023 void *argp1 = 0 ;
28024 int res1 = 0 ;
28025 PyObject *swig_obj[1] ;
28026
28027 if (!args) SWIG_fail;
28028 swig_obj[0] = args;
28029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28030 if (!SWIG_IsOK(res1)) {
28031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28032 }
28033 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28034 {
28035 PyThreadState* __tstate = wxPyBeginAllowThreads();
28036 {
28037 wxTimeSpan &_result_ref = (arg1)->operator -();
28038 result = (wxTimeSpan *) &_result_ref;
28039 }
28040 wxPyEndAllowThreads(__tstate);
28041 if (PyErr_Occurred()) SWIG_fail;
28042 }
28043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28044 return resultobj;
28045 fail:
28046 return NULL;
28047 }
28048
28049
28050 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28051 PyObject *resultobj = 0;
28052 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28053 wxTimeSpan *arg2 = 0 ;
28054 wxTimeSpan result;
28055 void *argp1 = 0 ;
28056 int res1 = 0 ;
28057 void *argp2 = 0 ;
28058 int res2 = 0 ;
28059 PyObject * obj0 = 0 ;
28060 PyObject * obj1 = 0 ;
28061 char * kwnames[] = {
28062 (char *) "self",(char *) "other", NULL
28063 };
28064
28065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28067 if (!SWIG_IsOK(res1)) {
28068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28069 }
28070 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28071 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28072 if (!SWIG_IsOK(res2)) {
28073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28074 }
28075 if (!argp2) {
28076 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28077 }
28078 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28079 {
28080 PyThreadState* __tstate = wxPyBeginAllowThreads();
28081 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28086 return resultobj;
28087 fail:
28088 return NULL;
28089 }
28090
28091
28092 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28093 PyObject *resultobj = 0;
28094 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28095 wxTimeSpan *arg2 = 0 ;
28096 wxTimeSpan result;
28097 void *argp1 = 0 ;
28098 int res1 = 0 ;
28099 void *argp2 = 0 ;
28100 int res2 = 0 ;
28101 PyObject * obj0 = 0 ;
28102 PyObject * obj1 = 0 ;
28103 char * kwnames[] = {
28104 (char *) "self",(char *) "other", NULL
28105 };
28106
28107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28109 if (!SWIG_IsOK(res1)) {
28110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28111 }
28112 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28114 if (!SWIG_IsOK(res2)) {
28115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28116 }
28117 if (!argp2) {
28118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28119 }
28120 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28135 PyObject *resultobj = 0;
28136 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28137 int arg2 ;
28138 wxTimeSpan result;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 int val2 ;
28142 int ecode2 = 0 ;
28143 PyObject * obj0 = 0 ;
28144 PyObject * obj1 = 0 ;
28145 char * kwnames[] = {
28146 (char *) "self",(char *) "n", NULL
28147 };
28148
28149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28151 if (!SWIG_IsOK(res1)) {
28152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28153 }
28154 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28155 ecode2 = SWIG_AsVal_int(obj1, &val2);
28156 if (!SWIG_IsOK(ecode2)) {
28157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28158 }
28159 arg2 = static_cast< int >(val2);
28160 {
28161 PyThreadState* __tstate = wxPyBeginAllowThreads();
28162 result = wxTimeSpan___mul__(arg1,arg2);
28163 wxPyEndAllowThreads(__tstate);
28164 if (PyErr_Occurred()) SWIG_fail;
28165 }
28166 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28167 return resultobj;
28168 fail:
28169 return NULL;
28170 }
28171
28172
28173 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28174 PyObject *resultobj = 0;
28175 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28176 int arg2 ;
28177 wxTimeSpan result;
28178 void *argp1 = 0 ;
28179 int res1 = 0 ;
28180 int val2 ;
28181 int ecode2 = 0 ;
28182 PyObject * obj0 = 0 ;
28183 PyObject * obj1 = 0 ;
28184 char * kwnames[] = {
28185 (char *) "self",(char *) "n", NULL
28186 };
28187
28188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28190 if (!SWIG_IsOK(res1)) {
28191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28192 }
28193 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28194 ecode2 = SWIG_AsVal_int(obj1, &val2);
28195 if (!SWIG_IsOK(ecode2)) {
28196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28197 }
28198 arg2 = static_cast< int >(val2);
28199 {
28200 PyThreadState* __tstate = wxPyBeginAllowThreads();
28201 result = wxTimeSpan___rmul__(arg1,arg2);
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28206 return resultobj;
28207 fail:
28208 return NULL;
28209 }
28210
28211
28212 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28213 PyObject *resultobj = 0;
28214 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28215 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28216 bool result;
28217 void *argp1 = 0 ;
28218 int res1 = 0 ;
28219 void *argp2 = 0 ;
28220 int res2 = 0 ;
28221 PyObject * obj0 = 0 ;
28222 PyObject * obj1 = 0 ;
28223 char * kwnames[] = {
28224 (char *) "self",(char *) "other", NULL
28225 };
28226
28227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28229 if (!SWIG_IsOK(res1)) {
28230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28231 }
28232 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28233 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28234 if (!SWIG_IsOK(res2)) {
28235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28236 }
28237 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28238 {
28239 PyThreadState* __tstate = wxPyBeginAllowThreads();
28240 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28241 wxPyEndAllowThreads(__tstate);
28242 if (PyErr_Occurred()) SWIG_fail;
28243 }
28244 {
28245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28246 }
28247 return resultobj;
28248 fail:
28249 return NULL;
28250 }
28251
28252
28253 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28254 PyObject *resultobj = 0;
28255 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28256 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28257 bool result;
28258 void *argp1 = 0 ;
28259 int res1 = 0 ;
28260 void *argp2 = 0 ;
28261 int res2 = 0 ;
28262 PyObject * obj0 = 0 ;
28263 PyObject * obj1 = 0 ;
28264 char * kwnames[] = {
28265 (char *) "self",(char *) "other", NULL
28266 };
28267
28268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28270 if (!SWIG_IsOK(res1)) {
28271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28272 }
28273 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28275 if (!SWIG_IsOK(res2)) {
28276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28277 }
28278 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28279 {
28280 PyThreadState* __tstate = wxPyBeginAllowThreads();
28281 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28282 wxPyEndAllowThreads(__tstate);
28283 if (PyErr_Occurred()) SWIG_fail;
28284 }
28285 {
28286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28287 }
28288 return resultobj;
28289 fail:
28290 return NULL;
28291 }
28292
28293
28294 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28295 PyObject *resultobj = 0;
28296 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28297 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28298 bool result;
28299 void *argp1 = 0 ;
28300 int res1 = 0 ;
28301 void *argp2 = 0 ;
28302 int res2 = 0 ;
28303 PyObject * obj0 = 0 ;
28304 PyObject * obj1 = 0 ;
28305 char * kwnames[] = {
28306 (char *) "self",(char *) "other", NULL
28307 };
28308
28309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28311 if (!SWIG_IsOK(res1)) {
28312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28313 }
28314 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28315 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28316 if (!SWIG_IsOK(res2)) {
28317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28318 }
28319 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28320 {
28321 PyThreadState* __tstate = wxPyBeginAllowThreads();
28322 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28323 wxPyEndAllowThreads(__tstate);
28324 if (PyErr_Occurred()) SWIG_fail;
28325 }
28326 {
28327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28328 }
28329 return resultobj;
28330 fail:
28331 return NULL;
28332 }
28333
28334
28335 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28336 PyObject *resultobj = 0;
28337 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28338 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28339 bool result;
28340 void *argp1 = 0 ;
28341 int res1 = 0 ;
28342 void *argp2 = 0 ;
28343 int res2 = 0 ;
28344 PyObject * obj0 = 0 ;
28345 PyObject * obj1 = 0 ;
28346 char * kwnames[] = {
28347 (char *) "self",(char *) "other", NULL
28348 };
28349
28350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28352 if (!SWIG_IsOK(res1)) {
28353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28354 }
28355 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28356 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28357 if (!SWIG_IsOK(res2)) {
28358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28359 }
28360 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28361 {
28362 PyThreadState* __tstate = wxPyBeginAllowThreads();
28363 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28364 wxPyEndAllowThreads(__tstate);
28365 if (PyErr_Occurred()) SWIG_fail;
28366 }
28367 {
28368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28369 }
28370 return resultobj;
28371 fail:
28372 return NULL;
28373 }
28374
28375
28376 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28377 PyObject *resultobj = 0;
28378 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28379 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28380 bool result;
28381 void *argp1 = 0 ;
28382 int res1 = 0 ;
28383 void *argp2 = 0 ;
28384 int res2 = 0 ;
28385 PyObject * obj0 = 0 ;
28386 PyObject * obj1 = 0 ;
28387 char * kwnames[] = {
28388 (char *) "self",(char *) "other", NULL
28389 };
28390
28391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28393 if (!SWIG_IsOK(res1)) {
28394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28395 }
28396 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28397 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28398 if (!SWIG_IsOK(res2)) {
28399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28400 }
28401 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28402 {
28403 PyThreadState* __tstate = wxPyBeginAllowThreads();
28404 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28405 wxPyEndAllowThreads(__tstate);
28406 if (PyErr_Occurred()) SWIG_fail;
28407 }
28408 {
28409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28410 }
28411 return resultobj;
28412 fail:
28413 return NULL;
28414 }
28415
28416
28417 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28418 PyObject *resultobj = 0;
28419 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28420 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28421 bool result;
28422 void *argp1 = 0 ;
28423 int res1 = 0 ;
28424 void *argp2 = 0 ;
28425 int res2 = 0 ;
28426 PyObject * obj0 = 0 ;
28427 PyObject * obj1 = 0 ;
28428 char * kwnames[] = {
28429 (char *) "self",(char *) "other", NULL
28430 };
28431
28432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28434 if (!SWIG_IsOK(res1)) {
28435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28436 }
28437 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28438 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28439 if (!SWIG_IsOK(res2)) {
28440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28441 }
28442 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28443 {
28444 PyThreadState* __tstate = wxPyBeginAllowThreads();
28445 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 {
28450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28451 }
28452 return resultobj;
28453 fail:
28454 return NULL;
28455 }
28456
28457
28458 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28459 PyObject *resultobj = 0;
28460 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28461 bool result;
28462 void *argp1 = 0 ;
28463 int res1 = 0 ;
28464 PyObject *swig_obj[1] ;
28465
28466 if (!args) SWIG_fail;
28467 swig_obj[0] = args;
28468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28469 if (!SWIG_IsOK(res1)) {
28470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28471 }
28472 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28473 {
28474 PyThreadState* __tstate = wxPyBeginAllowThreads();
28475 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 {
28480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28481 }
28482 return resultobj;
28483 fail:
28484 return NULL;
28485 }
28486
28487
28488 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28489 PyObject *resultobj = 0;
28490 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28491 bool result;
28492 void *argp1 = 0 ;
28493 int res1 = 0 ;
28494 PyObject *swig_obj[1] ;
28495
28496 if (!args) SWIG_fail;
28497 swig_obj[0] = args;
28498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28499 if (!SWIG_IsOK(res1)) {
28500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28501 }
28502 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28503 {
28504 PyThreadState* __tstate = wxPyBeginAllowThreads();
28505 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28506 wxPyEndAllowThreads(__tstate);
28507 if (PyErr_Occurred()) SWIG_fail;
28508 }
28509 {
28510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28511 }
28512 return resultobj;
28513 fail:
28514 return NULL;
28515 }
28516
28517
28518 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28519 PyObject *resultobj = 0;
28520 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28521 bool result;
28522 void *argp1 = 0 ;
28523 int res1 = 0 ;
28524 PyObject *swig_obj[1] ;
28525
28526 if (!args) SWIG_fail;
28527 swig_obj[0] = args;
28528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28529 if (!SWIG_IsOK(res1)) {
28530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28531 }
28532 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28533 {
28534 PyThreadState* __tstate = wxPyBeginAllowThreads();
28535 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28536 wxPyEndAllowThreads(__tstate);
28537 if (PyErr_Occurred()) SWIG_fail;
28538 }
28539 {
28540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28541 }
28542 return resultobj;
28543 fail:
28544 return NULL;
28545 }
28546
28547
28548 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28549 PyObject *resultobj = 0;
28550 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28551 wxTimeSpan *arg2 = 0 ;
28552 bool result;
28553 void *argp1 = 0 ;
28554 int res1 = 0 ;
28555 void *argp2 = 0 ;
28556 int res2 = 0 ;
28557 PyObject * obj0 = 0 ;
28558 PyObject * obj1 = 0 ;
28559 char * kwnames[] = {
28560 (char *) "self",(char *) "ts", NULL
28561 };
28562
28563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28565 if (!SWIG_IsOK(res1)) {
28566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28567 }
28568 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28569 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28570 if (!SWIG_IsOK(res2)) {
28571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28572 }
28573 if (!argp2) {
28574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28575 }
28576 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28577 {
28578 PyThreadState* __tstate = wxPyBeginAllowThreads();
28579 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((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_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28593 PyObject *resultobj = 0;
28594 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28595 wxTimeSpan *arg2 = 0 ;
28596 bool result;
28597 void *argp1 = 0 ;
28598 int res1 = 0 ;
28599 void *argp2 = 0 ;
28600 int res2 = 0 ;
28601 PyObject * obj0 = 0 ;
28602 PyObject * obj1 = 0 ;
28603 char * kwnames[] = {
28604 (char *) "self",(char *) "ts", NULL
28605 };
28606
28607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28609 if (!SWIG_IsOK(res1)) {
28610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28611 }
28612 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28613 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28614 if (!SWIG_IsOK(res2)) {
28615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28616 }
28617 if (!argp2) {
28618 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28619 }
28620 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28621 {
28622 PyThreadState* __tstate = wxPyBeginAllowThreads();
28623 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 {
28628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28629 }
28630 return resultobj;
28631 fail:
28632 return NULL;
28633 }
28634
28635
28636 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28637 PyObject *resultobj = 0;
28638 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28639 wxTimeSpan *arg2 = 0 ;
28640 bool result;
28641 void *argp1 = 0 ;
28642 int res1 = 0 ;
28643 void *argp2 = 0 ;
28644 int res2 = 0 ;
28645 PyObject * obj0 = 0 ;
28646 PyObject * obj1 = 0 ;
28647 char * kwnames[] = {
28648 (char *) "self",(char *) "t", NULL
28649 };
28650
28651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28653 if (!SWIG_IsOK(res1)) {
28654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28655 }
28656 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28657 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28658 if (!SWIG_IsOK(res2)) {
28659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28660 }
28661 if (!argp2) {
28662 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28663 }
28664 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28665 {
28666 PyThreadState* __tstate = wxPyBeginAllowThreads();
28667 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28668 wxPyEndAllowThreads(__tstate);
28669 if (PyErr_Occurred()) SWIG_fail;
28670 }
28671 {
28672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28673 }
28674 return resultobj;
28675 fail:
28676 return NULL;
28677 }
28678
28679
28680 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28681 PyObject *resultobj = 0;
28682 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28683 int result;
28684 void *argp1 = 0 ;
28685 int res1 = 0 ;
28686 PyObject *swig_obj[1] ;
28687
28688 if (!args) SWIG_fail;
28689 swig_obj[0] = args;
28690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28691 if (!SWIG_IsOK(res1)) {
28692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28693 }
28694 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28695 {
28696 PyThreadState* __tstate = wxPyBeginAllowThreads();
28697 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28698 wxPyEndAllowThreads(__tstate);
28699 if (PyErr_Occurred()) SWIG_fail;
28700 }
28701 resultobj = SWIG_From_int(static_cast< int >(result));
28702 return resultobj;
28703 fail:
28704 return NULL;
28705 }
28706
28707
28708 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28709 PyObject *resultobj = 0;
28710 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28711 int result;
28712 void *argp1 = 0 ;
28713 int res1 = 0 ;
28714 PyObject *swig_obj[1] ;
28715
28716 if (!args) SWIG_fail;
28717 swig_obj[0] = args;
28718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28719 if (!SWIG_IsOK(res1)) {
28720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28721 }
28722 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28726 wxPyEndAllowThreads(__tstate);
28727 if (PyErr_Occurred()) SWIG_fail;
28728 }
28729 resultobj = SWIG_From_int(static_cast< int >(result));
28730 return resultobj;
28731 fail:
28732 return NULL;
28733 }
28734
28735
28736 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28737 PyObject *resultobj = 0;
28738 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28739 int result;
28740 void *argp1 = 0 ;
28741 int res1 = 0 ;
28742 PyObject *swig_obj[1] ;
28743
28744 if (!args) SWIG_fail;
28745 swig_obj[0] = args;
28746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28747 if (!SWIG_IsOK(res1)) {
28748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28749 }
28750 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 resultobj = SWIG_From_int(static_cast< int >(result));
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28765 PyObject *resultobj = 0;
28766 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28767 int result;
28768 void *argp1 = 0 ;
28769 int res1 = 0 ;
28770 PyObject *swig_obj[1] ;
28771
28772 if (!args) SWIG_fail;
28773 swig_obj[0] = args;
28774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28775 if (!SWIG_IsOK(res1)) {
28776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28777 }
28778 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28779 {
28780 PyThreadState* __tstate = wxPyBeginAllowThreads();
28781 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 resultobj = SWIG_From_int(static_cast< int >(result));
28786 return resultobj;
28787 fail:
28788 return NULL;
28789 }
28790
28791
28792 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28793 PyObject *resultobj = 0;
28794 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28795 wxLongLong result;
28796 void *argp1 = 0 ;
28797 int res1 = 0 ;
28798 PyObject *swig_obj[1] ;
28799
28800 if (!args) SWIG_fail;
28801 swig_obj[0] = args;
28802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28803 if (!SWIG_IsOK(res1)) {
28804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28805 }
28806 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28807 {
28808 PyThreadState* __tstate = wxPyBeginAllowThreads();
28809 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28810 wxPyEndAllowThreads(__tstate);
28811 if (PyErr_Occurred()) SWIG_fail;
28812 }
28813 {
28814 PyObject *hi, *lo, *shifter, *shifted;
28815 hi = PyLong_FromLong( (&result)->GetHi() );
28816 lo = PyLong_FromLong( (&result)->GetLo() );
28817 shifter = PyLong_FromLong(32);
28818 shifted = PyNumber_Lshift(hi, shifter);
28819 resultobj = PyNumber_Or(shifted, lo);
28820 Py_DECREF(hi);
28821 Py_DECREF(lo);
28822 Py_DECREF(shifter);
28823 Py_DECREF(shifted);
28824 }
28825 return resultobj;
28826 fail:
28827 return NULL;
28828 }
28829
28830
28831 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28832 PyObject *resultobj = 0;
28833 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28834 wxLongLong result;
28835 void *argp1 = 0 ;
28836 int res1 = 0 ;
28837 PyObject *swig_obj[1] ;
28838
28839 if (!args) SWIG_fail;
28840 swig_obj[0] = args;
28841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28842 if (!SWIG_IsOK(res1)) {
28843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28844 }
28845 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28846 {
28847 PyThreadState* __tstate = wxPyBeginAllowThreads();
28848 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28849 wxPyEndAllowThreads(__tstate);
28850 if (PyErr_Occurred()) SWIG_fail;
28851 }
28852 {
28853 PyObject *hi, *lo, *shifter, *shifted;
28854 hi = PyLong_FromLong( (&result)->GetHi() );
28855 lo = PyLong_FromLong( (&result)->GetLo() );
28856 shifter = PyLong_FromLong(32);
28857 shifted = PyNumber_Lshift(hi, shifter);
28858 resultobj = PyNumber_Or(shifted, lo);
28859 Py_DECREF(hi);
28860 Py_DECREF(lo);
28861 Py_DECREF(shifter);
28862 Py_DECREF(shifted);
28863 }
28864 return resultobj;
28865 fail:
28866 return NULL;
28867 }
28868
28869
28870 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28871 PyObject *resultobj = 0;
28872 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28873 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28874 wxString *arg2 = (wxString *) &arg2_defvalue ;
28875 wxString result;
28876 void *argp1 = 0 ;
28877 int res1 = 0 ;
28878 bool temp2 = false ;
28879 PyObject * obj0 = 0 ;
28880 PyObject * obj1 = 0 ;
28881 char * kwnames[] = {
28882 (char *) "self",(char *) "format", NULL
28883 };
28884
28885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28887 if (!SWIG_IsOK(res1)) {
28888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28889 }
28890 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28891 if (obj1) {
28892 {
28893 arg2 = wxString_in_helper(obj1);
28894 if (arg2 == NULL) SWIG_fail;
28895 temp2 = true;
28896 }
28897 }
28898 {
28899 PyThreadState* __tstate = wxPyBeginAllowThreads();
28900 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 {
28905 #if wxUSE_UNICODE
28906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28907 #else
28908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28909 #endif
28910 }
28911 {
28912 if (temp2)
28913 delete arg2;
28914 }
28915 return resultobj;
28916 fail:
28917 {
28918 if (temp2)
28919 delete arg2;
28920 }
28921 return NULL;
28922 }
28923
28924
28925 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28926 PyObject *obj;
28927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28928 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28929 return SWIG_Py_Void();
28930 }
28931
28932 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28933 return SWIG_Python_InitShadowInstance(args);
28934 }
28935
28936 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28937 PyObject *resultobj = 0;
28938 int arg1 = (int) 0 ;
28939 int arg2 = (int) 0 ;
28940 int arg3 = (int) 0 ;
28941 int arg4 = (int) 0 ;
28942 wxDateSpan *result = 0 ;
28943 int val1 ;
28944 int ecode1 = 0 ;
28945 int val2 ;
28946 int ecode2 = 0 ;
28947 int val3 ;
28948 int ecode3 = 0 ;
28949 int val4 ;
28950 int ecode4 = 0 ;
28951 PyObject * obj0 = 0 ;
28952 PyObject * obj1 = 0 ;
28953 PyObject * obj2 = 0 ;
28954 PyObject * obj3 = 0 ;
28955 char * kwnames[] = {
28956 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28957 };
28958
28959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28960 if (obj0) {
28961 ecode1 = SWIG_AsVal_int(obj0, &val1);
28962 if (!SWIG_IsOK(ecode1)) {
28963 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28964 }
28965 arg1 = static_cast< int >(val1);
28966 }
28967 if (obj1) {
28968 ecode2 = SWIG_AsVal_int(obj1, &val2);
28969 if (!SWIG_IsOK(ecode2)) {
28970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28971 }
28972 arg2 = static_cast< int >(val2);
28973 }
28974 if (obj2) {
28975 ecode3 = SWIG_AsVal_int(obj2, &val3);
28976 if (!SWIG_IsOK(ecode3)) {
28977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28978 }
28979 arg3 = static_cast< int >(val3);
28980 }
28981 if (obj3) {
28982 ecode4 = SWIG_AsVal_int(obj3, &val4);
28983 if (!SWIG_IsOK(ecode4)) {
28984 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28985 }
28986 arg4 = static_cast< int >(val4);
28987 }
28988 {
28989 PyThreadState* __tstate = wxPyBeginAllowThreads();
28990 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28991 wxPyEndAllowThreads(__tstate);
28992 if (PyErr_Occurred()) SWIG_fail;
28993 }
28994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29002 PyObject *resultobj = 0;
29003 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29004 void *argp1 = 0 ;
29005 int res1 = 0 ;
29006 PyObject *swig_obj[1] ;
29007
29008 if (!args) SWIG_fail;
29009 swig_obj[0] = args;
29010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29011 if (!SWIG_IsOK(res1)) {
29012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29013 }
29014 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29015 {
29016 PyThreadState* __tstate = wxPyBeginAllowThreads();
29017 delete arg1;
29018
29019 wxPyEndAllowThreads(__tstate);
29020 if (PyErr_Occurred()) SWIG_fail;
29021 }
29022 resultobj = SWIG_Py_Void();
29023 return resultobj;
29024 fail:
29025 return NULL;
29026 }
29027
29028
29029 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29030 PyObject *resultobj = 0;
29031 int arg1 ;
29032 wxDateSpan result;
29033 int val1 ;
29034 int ecode1 = 0 ;
29035 PyObject * obj0 = 0 ;
29036 char * kwnames[] = {
29037 (char *) "days", NULL
29038 };
29039
29040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29041 ecode1 = SWIG_AsVal_int(obj0, &val1);
29042 if (!SWIG_IsOK(ecode1)) {
29043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29044 }
29045 arg1 = static_cast< int >(val1);
29046 {
29047 PyThreadState* __tstate = wxPyBeginAllowThreads();
29048 result = wxDateSpan::Days(arg1);
29049 wxPyEndAllowThreads(__tstate);
29050 if (PyErr_Occurred()) SWIG_fail;
29051 }
29052 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29053 return resultobj;
29054 fail:
29055 return NULL;
29056 }
29057
29058
29059 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29060 PyObject *resultobj = 0;
29061 wxDateSpan result;
29062
29063 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29064 {
29065 PyThreadState* __tstate = wxPyBeginAllowThreads();
29066 result = wxDateSpan::Day();
29067 wxPyEndAllowThreads(__tstate);
29068 if (PyErr_Occurred()) SWIG_fail;
29069 }
29070 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29071 return resultobj;
29072 fail:
29073 return NULL;
29074 }
29075
29076
29077 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj = 0;
29079 int arg1 ;
29080 wxDateSpan result;
29081 int val1 ;
29082 int ecode1 = 0 ;
29083 PyObject * obj0 = 0 ;
29084 char * kwnames[] = {
29085 (char *) "weeks", NULL
29086 };
29087
29088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29089 ecode1 = SWIG_AsVal_int(obj0, &val1);
29090 if (!SWIG_IsOK(ecode1)) {
29091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29092 }
29093 arg1 = static_cast< int >(val1);
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 result = wxDateSpan::Weeks(arg1);
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 PyObject *resultobj = 0;
29109 wxDateSpan result;
29110
29111 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29112 {
29113 PyThreadState* __tstate = wxPyBeginAllowThreads();
29114 result = wxDateSpan::Week();
29115 wxPyEndAllowThreads(__tstate);
29116 if (PyErr_Occurred()) SWIG_fail;
29117 }
29118 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29119 return resultobj;
29120 fail:
29121 return NULL;
29122 }
29123
29124
29125 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29126 PyObject *resultobj = 0;
29127 int arg1 ;
29128 wxDateSpan result;
29129 int val1 ;
29130 int ecode1 = 0 ;
29131 PyObject * obj0 = 0 ;
29132 char * kwnames[] = {
29133 (char *) "mon", NULL
29134 };
29135
29136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29137 ecode1 = SWIG_AsVal_int(obj0, &val1);
29138 if (!SWIG_IsOK(ecode1)) {
29139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29140 }
29141 arg1 = static_cast< int >(val1);
29142 {
29143 PyThreadState* __tstate = wxPyBeginAllowThreads();
29144 result = wxDateSpan::Months(arg1);
29145 wxPyEndAllowThreads(__tstate);
29146 if (PyErr_Occurred()) SWIG_fail;
29147 }
29148 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29149 return resultobj;
29150 fail:
29151 return NULL;
29152 }
29153
29154
29155 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29156 PyObject *resultobj = 0;
29157 wxDateSpan result;
29158
29159 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29160 {
29161 PyThreadState* __tstate = wxPyBeginAllowThreads();
29162 result = wxDateSpan::Month();
29163 wxPyEndAllowThreads(__tstate);
29164 if (PyErr_Occurred()) SWIG_fail;
29165 }
29166 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29167 return resultobj;
29168 fail:
29169 return NULL;
29170 }
29171
29172
29173 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29174 PyObject *resultobj = 0;
29175 int arg1 ;
29176 wxDateSpan result;
29177 int val1 ;
29178 int ecode1 = 0 ;
29179 PyObject * obj0 = 0 ;
29180 char * kwnames[] = {
29181 (char *) "years", NULL
29182 };
29183
29184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29185 ecode1 = SWIG_AsVal_int(obj0, &val1);
29186 if (!SWIG_IsOK(ecode1)) {
29187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29188 }
29189 arg1 = static_cast< int >(val1);
29190 {
29191 PyThreadState* __tstate = wxPyBeginAllowThreads();
29192 result = wxDateSpan::Years(arg1);
29193 wxPyEndAllowThreads(__tstate);
29194 if (PyErr_Occurred()) SWIG_fail;
29195 }
29196 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29197 return resultobj;
29198 fail:
29199 return NULL;
29200 }
29201
29202
29203 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29204 PyObject *resultobj = 0;
29205 wxDateSpan result;
29206
29207 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29208 {
29209 PyThreadState* __tstate = wxPyBeginAllowThreads();
29210 result = wxDateSpan::Year();
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29215 return resultobj;
29216 fail:
29217 return NULL;
29218 }
29219
29220
29221 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29222 PyObject *resultobj = 0;
29223 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29224 int arg2 ;
29225 wxDateSpan *result = 0 ;
29226 void *argp1 = 0 ;
29227 int res1 = 0 ;
29228 int val2 ;
29229 int ecode2 = 0 ;
29230 PyObject * obj0 = 0 ;
29231 PyObject * obj1 = 0 ;
29232 char * kwnames[] = {
29233 (char *) "self",(char *) "n", NULL
29234 };
29235
29236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29238 if (!SWIG_IsOK(res1)) {
29239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29240 }
29241 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29242 ecode2 = SWIG_AsVal_int(obj1, &val2);
29243 if (!SWIG_IsOK(ecode2)) {
29244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29245 }
29246 arg2 = static_cast< int >(val2);
29247 {
29248 PyThreadState* __tstate = wxPyBeginAllowThreads();
29249 {
29250 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29251 result = (wxDateSpan *) &_result_ref;
29252 }
29253 wxPyEndAllowThreads(__tstate);
29254 if (PyErr_Occurred()) SWIG_fail;
29255 }
29256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29257 return resultobj;
29258 fail:
29259 return NULL;
29260 }
29261
29262
29263 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29264 PyObject *resultobj = 0;
29265 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29266 int arg2 ;
29267 wxDateSpan *result = 0 ;
29268 void *argp1 = 0 ;
29269 int res1 = 0 ;
29270 int val2 ;
29271 int ecode2 = 0 ;
29272 PyObject * obj0 = 0 ;
29273 PyObject * obj1 = 0 ;
29274 char * kwnames[] = {
29275 (char *) "self",(char *) "n", NULL
29276 };
29277
29278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29280 if (!SWIG_IsOK(res1)) {
29281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29282 }
29283 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29284 ecode2 = SWIG_AsVal_int(obj1, &val2);
29285 if (!SWIG_IsOK(ecode2)) {
29286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29287 }
29288 arg2 = static_cast< int >(val2);
29289 {
29290 PyThreadState* __tstate = wxPyBeginAllowThreads();
29291 {
29292 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29293 result = (wxDateSpan *) &_result_ref;
29294 }
29295 wxPyEndAllowThreads(__tstate);
29296 if (PyErr_Occurred()) SWIG_fail;
29297 }
29298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29306 PyObject *resultobj = 0;
29307 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29308 int arg2 ;
29309 wxDateSpan *result = 0 ;
29310 void *argp1 = 0 ;
29311 int res1 = 0 ;
29312 int val2 ;
29313 int ecode2 = 0 ;
29314 PyObject * obj0 = 0 ;
29315 PyObject * obj1 = 0 ;
29316 char * kwnames[] = {
29317 (char *) "self",(char *) "n", NULL
29318 };
29319
29320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29322 if (!SWIG_IsOK(res1)) {
29323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29324 }
29325 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29326 ecode2 = SWIG_AsVal_int(obj1, &val2);
29327 if (!SWIG_IsOK(ecode2)) {
29328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29329 }
29330 arg2 = static_cast< int >(val2);
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 {
29334 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29335 result = (wxDateSpan *) &_result_ref;
29336 }
29337 wxPyEndAllowThreads(__tstate);
29338 if (PyErr_Occurred()) SWIG_fail;
29339 }
29340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29341 return resultobj;
29342 fail:
29343 return NULL;
29344 }
29345
29346
29347 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29348 PyObject *resultobj = 0;
29349 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29350 int arg2 ;
29351 wxDateSpan *result = 0 ;
29352 void *argp1 = 0 ;
29353 int res1 = 0 ;
29354 int val2 ;
29355 int ecode2 = 0 ;
29356 PyObject * obj0 = 0 ;
29357 PyObject * obj1 = 0 ;
29358 char * kwnames[] = {
29359 (char *) "self",(char *) "n", NULL
29360 };
29361
29362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29364 if (!SWIG_IsOK(res1)) {
29365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29366 }
29367 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29368 ecode2 = SWIG_AsVal_int(obj1, &val2);
29369 if (!SWIG_IsOK(ecode2)) {
29370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29371 }
29372 arg2 = static_cast< int >(val2);
29373 {
29374 PyThreadState* __tstate = wxPyBeginAllowThreads();
29375 {
29376 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29377 result = (wxDateSpan *) &_result_ref;
29378 }
29379 wxPyEndAllowThreads(__tstate);
29380 if (PyErr_Occurred()) SWIG_fail;
29381 }
29382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29383 return resultobj;
29384 fail:
29385 return NULL;
29386 }
29387
29388
29389 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29390 PyObject *resultobj = 0;
29391 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29392 int result;
29393 void *argp1 = 0 ;
29394 int res1 = 0 ;
29395 PyObject *swig_obj[1] ;
29396
29397 if (!args) SWIG_fail;
29398 swig_obj[0] = args;
29399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29400 if (!SWIG_IsOK(res1)) {
29401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29402 }
29403 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29404 {
29405 PyThreadState* __tstate = wxPyBeginAllowThreads();
29406 result = (int)((wxDateSpan const *)arg1)->GetYears();
29407 wxPyEndAllowThreads(__tstate);
29408 if (PyErr_Occurred()) SWIG_fail;
29409 }
29410 resultobj = SWIG_From_int(static_cast< int >(result));
29411 return resultobj;
29412 fail:
29413 return NULL;
29414 }
29415
29416
29417 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29418 PyObject *resultobj = 0;
29419 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29420 int result;
29421 void *argp1 = 0 ;
29422 int res1 = 0 ;
29423 PyObject *swig_obj[1] ;
29424
29425 if (!args) SWIG_fail;
29426 swig_obj[0] = args;
29427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29428 if (!SWIG_IsOK(res1)) {
29429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29430 }
29431 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29432 {
29433 PyThreadState* __tstate = wxPyBeginAllowThreads();
29434 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29435 wxPyEndAllowThreads(__tstate);
29436 if (PyErr_Occurred()) SWIG_fail;
29437 }
29438 resultobj = SWIG_From_int(static_cast< int >(result));
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29446 PyObject *resultobj = 0;
29447 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29448 int result;
29449 void *argp1 = 0 ;
29450 int res1 = 0 ;
29451 PyObject *swig_obj[1] ;
29452
29453 if (!args) SWIG_fail;
29454 swig_obj[0] = args;
29455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29456 if (!SWIG_IsOK(res1)) {
29457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29458 }
29459 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29463 wxPyEndAllowThreads(__tstate);
29464 if (PyErr_Occurred()) SWIG_fail;
29465 }
29466 resultobj = SWIG_From_int(static_cast< int >(result));
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474 PyObject *resultobj = 0;
29475 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29476 int result;
29477 void *argp1 = 0 ;
29478 int res1 = 0 ;
29479 PyObject *swig_obj[1] ;
29480
29481 if (!args) SWIG_fail;
29482 swig_obj[0] = args;
29483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29484 if (!SWIG_IsOK(res1)) {
29485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29486 }
29487 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29488 {
29489 PyThreadState* __tstate = wxPyBeginAllowThreads();
29490 result = (int)((wxDateSpan const *)arg1)->GetDays();
29491 wxPyEndAllowThreads(__tstate);
29492 if (PyErr_Occurred()) SWIG_fail;
29493 }
29494 resultobj = SWIG_From_int(static_cast< int >(result));
29495 return resultobj;
29496 fail:
29497 return NULL;
29498 }
29499
29500
29501 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29502 PyObject *resultobj = 0;
29503 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29504 int result;
29505 void *argp1 = 0 ;
29506 int res1 = 0 ;
29507 PyObject *swig_obj[1] ;
29508
29509 if (!args) SWIG_fail;
29510 swig_obj[0] = args;
29511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29512 if (!SWIG_IsOK(res1)) {
29513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29514 }
29515 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29516 {
29517 PyThreadState* __tstate = wxPyBeginAllowThreads();
29518 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29519 wxPyEndAllowThreads(__tstate);
29520 if (PyErr_Occurred()) SWIG_fail;
29521 }
29522 resultobj = SWIG_From_int(static_cast< int >(result));
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29530 PyObject *resultobj = 0;
29531 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29532 wxDateSpan *arg2 = 0 ;
29533 wxDateSpan *result = 0 ;
29534 void *argp1 = 0 ;
29535 int res1 = 0 ;
29536 void *argp2 = 0 ;
29537 int res2 = 0 ;
29538 PyObject * obj0 = 0 ;
29539 PyObject * obj1 = 0 ;
29540 char * kwnames[] = {
29541 (char *) "self",(char *) "other", NULL
29542 };
29543
29544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29546 if (!SWIG_IsOK(res1)) {
29547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29548 }
29549 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29550 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29551 if (!SWIG_IsOK(res2)) {
29552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29553 }
29554 if (!argp2) {
29555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29556 }
29557 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29558 {
29559 PyThreadState* __tstate = wxPyBeginAllowThreads();
29560 {
29561 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29562 result = (wxDateSpan *) &_result_ref;
29563 }
29564 wxPyEndAllowThreads(__tstate);
29565 if (PyErr_Occurred()) SWIG_fail;
29566 }
29567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29568 return resultobj;
29569 fail:
29570 return NULL;
29571 }
29572
29573
29574 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29575 PyObject *resultobj = 0;
29576 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29577 wxDateSpan *arg2 = 0 ;
29578 wxDateSpan *result = 0 ;
29579 void *argp1 = 0 ;
29580 int res1 = 0 ;
29581 void *argp2 = 0 ;
29582 int res2 = 0 ;
29583 PyObject * obj0 = 0 ;
29584 PyObject * obj1 = 0 ;
29585 char * kwnames[] = {
29586 (char *) "self",(char *) "other", NULL
29587 };
29588
29589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29591 if (!SWIG_IsOK(res1)) {
29592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29593 }
29594 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29595 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29596 if (!SWIG_IsOK(res2)) {
29597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29598 }
29599 if (!argp2) {
29600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29601 }
29602 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29603 {
29604 PyThreadState* __tstate = wxPyBeginAllowThreads();
29605 {
29606 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29607 result = (wxDateSpan *) &_result_ref;
29608 }
29609 wxPyEndAllowThreads(__tstate);
29610 if (PyErr_Occurred()) SWIG_fail;
29611 }
29612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29620 PyObject *resultobj = 0;
29621 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29622 wxDateSpan *result = 0 ;
29623 void *argp1 = 0 ;
29624 int res1 = 0 ;
29625 PyObject *swig_obj[1] ;
29626
29627 if (!args) SWIG_fail;
29628 swig_obj[0] = args;
29629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29630 if (!SWIG_IsOK(res1)) {
29631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29632 }
29633 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 {
29637 wxDateSpan &_result_ref = (arg1)->Neg();
29638 result = (wxDateSpan *) &_result_ref;
29639 }
29640 wxPyEndAllowThreads(__tstate);
29641 if (PyErr_Occurred()) SWIG_fail;
29642 }
29643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29644 return resultobj;
29645 fail:
29646 return NULL;
29647 }
29648
29649
29650 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29651 PyObject *resultobj = 0;
29652 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29653 int arg2 ;
29654 wxDateSpan *result = 0 ;
29655 void *argp1 = 0 ;
29656 int res1 = 0 ;
29657 int val2 ;
29658 int ecode2 = 0 ;
29659 PyObject * obj0 = 0 ;
29660 PyObject * obj1 = 0 ;
29661 char * kwnames[] = {
29662 (char *) "self",(char *) "factor", NULL
29663 };
29664
29665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29667 if (!SWIG_IsOK(res1)) {
29668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29669 }
29670 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29671 ecode2 = SWIG_AsVal_int(obj1, &val2);
29672 if (!SWIG_IsOK(ecode2)) {
29673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29674 }
29675 arg2 = static_cast< int >(val2);
29676 {
29677 PyThreadState* __tstate = wxPyBeginAllowThreads();
29678 {
29679 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29680 result = (wxDateSpan *) &_result_ref;
29681 }
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29693 PyObject *resultobj = 0;
29694 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29695 wxDateSpan *arg2 = 0 ;
29696 wxDateSpan *result = 0 ;
29697 void *argp1 = 0 ;
29698 int res1 = 0 ;
29699 void *argp2 = 0 ;
29700 int res2 = 0 ;
29701 PyObject * obj0 = 0 ;
29702 PyObject * obj1 = 0 ;
29703 char * kwnames[] = {
29704 (char *) "self",(char *) "other", NULL
29705 };
29706
29707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29709 if (!SWIG_IsOK(res1)) {
29710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29711 }
29712 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29713 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29714 if (!SWIG_IsOK(res2)) {
29715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29716 }
29717 if (!argp2) {
29718 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29719 }
29720 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29721 {
29722 PyThreadState* __tstate = wxPyBeginAllowThreads();
29723 {
29724 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29725 result = (wxDateSpan *) &_result_ref;
29726 }
29727 wxPyEndAllowThreads(__tstate);
29728 if (PyErr_Occurred()) SWIG_fail;
29729 }
29730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29731 return resultobj;
29732 fail:
29733 return NULL;
29734 }
29735
29736
29737 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29738 PyObject *resultobj = 0;
29739 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29740 wxDateSpan *arg2 = 0 ;
29741 wxDateSpan *result = 0 ;
29742 void *argp1 = 0 ;
29743 int res1 = 0 ;
29744 void *argp2 = 0 ;
29745 int res2 = 0 ;
29746 PyObject * obj0 = 0 ;
29747 PyObject * obj1 = 0 ;
29748 char * kwnames[] = {
29749 (char *) "self",(char *) "other", NULL
29750 };
29751
29752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29754 if (!SWIG_IsOK(res1)) {
29755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29756 }
29757 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29758 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29759 if (!SWIG_IsOK(res2)) {
29760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29761 }
29762 if (!argp2) {
29763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29764 }
29765 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29766 {
29767 PyThreadState* __tstate = wxPyBeginAllowThreads();
29768 {
29769 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29770 result = (wxDateSpan *) &_result_ref;
29771 }
29772 wxPyEndAllowThreads(__tstate);
29773 if (PyErr_Occurred()) SWIG_fail;
29774 }
29775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29776 return resultobj;
29777 fail:
29778 return NULL;
29779 }
29780
29781
29782 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29783 PyObject *resultobj = 0;
29784 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29785 wxDateSpan *result = 0 ;
29786 void *argp1 = 0 ;
29787 int res1 = 0 ;
29788 PyObject *swig_obj[1] ;
29789
29790 if (!args) SWIG_fail;
29791 swig_obj[0] = args;
29792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29793 if (!SWIG_IsOK(res1)) {
29794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29795 }
29796 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29797 {
29798 PyThreadState* __tstate = wxPyBeginAllowThreads();
29799 {
29800 wxDateSpan &_result_ref = (arg1)->operator -();
29801 result = (wxDateSpan *) &_result_ref;
29802 }
29803 wxPyEndAllowThreads(__tstate);
29804 if (PyErr_Occurred()) SWIG_fail;
29805 }
29806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29807 return resultobj;
29808 fail:
29809 return NULL;
29810 }
29811
29812
29813 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29814 PyObject *resultobj = 0;
29815 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29816 int arg2 ;
29817 wxDateSpan *result = 0 ;
29818 void *argp1 = 0 ;
29819 int res1 = 0 ;
29820 int val2 ;
29821 int ecode2 = 0 ;
29822 PyObject * obj0 = 0 ;
29823 PyObject * obj1 = 0 ;
29824 char * kwnames[] = {
29825 (char *) "self",(char *) "factor", NULL
29826 };
29827
29828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29830 if (!SWIG_IsOK(res1)) {
29831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29832 }
29833 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29834 ecode2 = SWIG_AsVal_int(obj1, &val2);
29835 if (!SWIG_IsOK(ecode2)) {
29836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29837 }
29838 arg2 = static_cast< int >(val2);
29839 {
29840 PyThreadState* __tstate = wxPyBeginAllowThreads();
29841 {
29842 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29843 result = (wxDateSpan *) &_result_ref;
29844 }
29845 wxPyEndAllowThreads(__tstate);
29846 if (PyErr_Occurred()) SWIG_fail;
29847 }
29848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29849 return resultobj;
29850 fail:
29851 return NULL;
29852 }
29853
29854
29855 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29856 PyObject *resultobj = 0;
29857 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29858 wxDateSpan *arg2 = 0 ;
29859 wxDateSpan result;
29860 void *argp1 = 0 ;
29861 int res1 = 0 ;
29862 void *argp2 = 0 ;
29863 int res2 = 0 ;
29864 PyObject * obj0 = 0 ;
29865 PyObject * obj1 = 0 ;
29866 char * kwnames[] = {
29867 (char *) "self",(char *) "other", NULL
29868 };
29869
29870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29872 if (!SWIG_IsOK(res1)) {
29873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29874 }
29875 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29876 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29877 if (!SWIG_IsOK(res2)) {
29878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29879 }
29880 if (!argp2) {
29881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29882 }
29883 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29884 {
29885 PyThreadState* __tstate = wxPyBeginAllowThreads();
29886 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29891 return resultobj;
29892 fail:
29893 return NULL;
29894 }
29895
29896
29897 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29898 PyObject *resultobj = 0;
29899 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29900 wxDateSpan *arg2 = 0 ;
29901 wxDateSpan result;
29902 void *argp1 = 0 ;
29903 int res1 = 0 ;
29904 void *argp2 = 0 ;
29905 int res2 = 0 ;
29906 PyObject * obj0 = 0 ;
29907 PyObject * obj1 = 0 ;
29908 char * kwnames[] = {
29909 (char *) "self",(char *) "other", NULL
29910 };
29911
29912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29914 if (!SWIG_IsOK(res1)) {
29915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29916 }
29917 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29918 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29919 if (!SWIG_IsOK(res2)) {
29920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29921 }
29922 if (!argp2) {
29923 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29924 }
29925 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29926 {
29927 PyThreadState* __tstate = wxPyBeginAllowThreads();
29928 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29929 wxPyEndAllowThreads(__tstate);
29930 if (PyErr_Occurred()) SWIG_fail;
29931 }
29932 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29933 return resultobj;
29934 fail:
29935 return NULL;
29936 }
29937
29938
29939 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29940 PyObject *resultobj = 0;
29941 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29942 int arg2 ;
29943 wxDateSpan result;
29944 void *argp1 = 0 ;
29945 int res1 = 0 ;
29946 int val2 ;
29947 int ecode2 = 0 ;
29948 PyObject * obj0 = 0 ;
29949 PyObject * obj1 = 0 ;
29950 char * kwnames[] = {
29951 (char *) "self",(char *) "n", NULL
29952 };
29953
29954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29956 if (!SWIG_IsOK(res1)) {
29957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29958 }
29959 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29960 ecode2 = SWIG_AsVal_int(obj1, &val2);
29961 if (!SWIG_IsOK(ecode2)) {
29962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29963 }
29964 arg2 = static_cast< int >(val2);
29965 {
29966 PyThreadState* __tstate = wxPyBeginAllowThreads();
29967 result = wxDateSpan___mul__(arg1,arg2);
29968 wxPyEndAllowThreads(__tstate);
29969 if (PyErr_Occurred()) SWIG_fail;
29970 }
29971 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29972 return resultobj;
29973 fail:
29974 return NULL;
29975 }
29976
29977
29978 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29979 PyObject *resultobj = 0;
29980 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29981 int arg2 ;
29982 wxDateSpan result;
29983 void *argp1 = 0 ;
29984 int res1 = 0 ;
29985 int val2 ;
29986 int ecode2 = 0 ;
29987 PyObject * obj0 = 0 ;
29988 PyObject * obj1 = 0 ;
29989 char * kwnames[] = {
29990 (char *) "self",(char *) "n", NULL
29991 };
29992
29993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29995 if (!SWIG_IsOK(res1)) {
29996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29997 }
29998 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29999 ecode2 = SWIG_AsVal_int(obj1, &val2);
30000 if (!SWIG_IsOK(ecode2)) {
30001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30002 }
30003 arg2 = static_cast< int >(val2);
30004 {
30005 PyThreadState* __tstate = wxPyBeginAllowThreads();
30006 result = wxDateSpan___rmul__(arg1,arg2);
30007 wxPyEndAllowThreads(__tstate);
30008 if (PyErr_Occurred()) SWIG_fail;
30009 }
30010 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30011 return resultobj;
30012 fail:
30013 return NULL;
30014 }
30015
30016
30017 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30018 PyObject *resultobj = 0;
30019 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30020 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30021 bool result;
30022 void *argp1 = 0 ;
30023 int res1 = 0 ;
30024 void *argp2 = 0 ;
30025 int res2 = 0 ;
30026 PyObject * obj0 = 0 ;
30027 PyObject * obj1 = 0 ;
30028 char * kwnames[] = {
30029 (char *) "self",(char *) "other", NULL
30030 };
30031
30032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30034 if (!SWIG_IsOK(res1)) {
30035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30036 }
30037 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30038 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30039 if (!SWIG_IsOK(res2)) {
30040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30041 }
30042 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30043 {
30044 PyThreadState* __tstate = wxPyBeginAllowThreads();
30045 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30046 wxPyEndAllowThreads(__tstate);
30047 if (PyErr_Occurred()) SWIG_fail;
30048 }
30049 {
30050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30051 }
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30059 PyObject *resultobj = 0;
30060 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30061 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30062 bool result;
30063 void *argp1 = 0 ;
30064 int res1 = 0 ;
30065 void *argp2 = 0 ;
30066 int res2 = 0 ;
30067 PyObject * obj0 = 0 ;
30068 PyObject * obj1 = 0 ;
30069 char * kwnames[] = {
30070 (char *) "self",(char *) "other", NULL
30071 };
30072
30073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30075 if (!SWIG_IsOK(res1)) {
30076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30077 }
30078 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30079 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30080 if (!SWIG_IsOK(res2)) {
30081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30082 }
30083 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30084 {
30085 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30087 wxPyEndAllowThreads(__tstate);
30088 if (PyErr_Occurred()) SWIG_fail;
30089 }
30090 {
30091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30092 }
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30100 PyObject *obj;
30101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30102 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30103 return SWIG_Py_Void();
30104 }
30105
30106 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30107 return SWIG_Python_InitShadowInstance(args);
30108 }
30109
30110 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30111 PyObject *resultobj = 0;
30112 long result;
30113
30114 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30115 {
30116 PyThreadState* __tstate = wxPyBeginAllowThreads();
30117 result = (long)wxGetLocalTime();
30118 wxPyEndAllowThreads(__tstate);
30119 if (PyErr_Occurred()) SWIG_fail;
30120 }
30121 resultobj = SWIG_From_long(static_cast< long >(result));
30122 return resultobj;
30123 fail:
30124 return NULL;
30125 }
30126
30127
30128 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30129 PyObject *resultobj = 0;
30130 long result;
30131
30132 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30133 {
30134 PyThreadState* __tstate = wxPyBeginAllowThreads();
30135 result = (long)wxGetUTCTime();
30136 wxPyEndAllowThreads(__tstate);
30137 if (PyErr_Occurred()) SWIG_fail;
30138 }
30139 resultobj = SWIG_From_long(static_cast< long >(result));
30140 return resultobj;
30141 fail:
30142 return NULL;
30143 }
30144
30145
30146 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30147 PyObject *resultobj = 0;
30148 long result;
30149
30150 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30151 {
30152 PyThreadState* __tstate = wxPyBeginAllowThreads();
30153 result = (long)wxGetCurrentTime();
30154 wxPyEndAllowThreads(__tstate);
30155 if (PyErr_Occurred()) SWIG_fail;
30156 }
30157 resultobj = SWIG_From_long(static_cast< long >(result));
30158 return resultobj;
30159 fail:
30160 return NULL;
30161 }
30162
30163
30164 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30165 PyObject *resultobj = 0;
30166 wxLongLong result;
30167
30168 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30169 {
30170 PyThreadState* __tstate = wxPyBeginAllowThreads();
30171 result = wxGetLocalTimeMillis();
30172 wxPyEndAllowThreads(__tstate);
30173 if (PyErr_Occurred()) SWIG_fail;
30174 }
30175 {
30176 PyObject *hi, *lo, *shifter, *shifted;
30177 hi = PyLong_FromLong( (&result)->GetHi() );
30178 lo = PyLong_FromLong( (&result)->GetLo() );
30179 shifter = PyLong_FromLong(32);
30180 shifted = PyNumber_Lshift(hi, shifter);
30181 resultobj = PyNumber_Or(shifted, lo);
30182 Py_DECREF(hi);
30183 Py_DECREF(lo);
30184 Py_DECREF(shifter);
30185 Py_DECREF(shifted);
30186 }
30187 return resultobj;
30188 fail:
30189 return NULL;
30190 }
30191
30192
30193 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30194 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30195 return 1;
30196 }
30197
30198
30199 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30200 PyObject *pyobj = 0;
30201
30202 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30203 return pyobj;
30204 }
30205
30206
30207 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30208 PyObject *resultobj = 0;
30209 wxDataFormatId arg1 ;
30210 wxDataFormat *result = 0 ;
30211 int val1 ;
30212 int ecode1 = 0 ;
30213 PyObject * obj0 = 0 ;
30214 char * kwnames[] = {
30215 (char *) "type", NULL
30216 };
30217
30218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30219 ecode1 = SWIG_AsVal_int(obj0, &val1);
30220 if (!SWIG_IsOK(ecode1)) {
30221 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30222 }
30223 arg1 = static_cast< wxDataFormatId >(val1);
30224 {
30225 PyThreadState* __tstate = wxPyBeginAllowThreads();
30226 result = (wxDataFormat *)new wxDataFormat(arg1);
30227 wxPyEndAllowThreads(__tstate);
30228 if (PyErr_Occurred()) SWIG_fail;
30229 }
30230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30231 return resultobj;
30232 fail:
30233 return NULL;
30234 }
30235
30236
30237 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30238 PyObject *resultobj = 0;
30239 wxString *arg1 = 0 ;
30240 wxDataFormat *result = 0 ;
30241 bool temp1 = false ;
30242 PyObject * obj0 = 0 ;
30243 char * kwnames[] = {
30244 (char *) "format", NULL
30245 };
30246
30247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30248 {
30249 arg1 = wxString_in_helper(obj0);
30250 if (arg1 == NULL) SWIG_fail;
30251 temp1 = true;
30252 }
30253 {
30254 PyThreadState* __tstate = wxPyBeginAllowThreads();
30255 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30260 {
30261 if (temp1)
30262 delete arg1;
30263 }
30264 return resultobj;
30265 fail:
30266 {
30267 if (temp1)
30268 delete arg1;
30269 }
30270 return NULL;
30271 }
30272
30273
30274 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30275 PyObject *resultobj = 0;
30276 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30277 void *argp1 = 0 ;
30278 int res1 = 0 ;
30279 PyObject *swig_obj[1] ;
30280
30281 if (!args) SWIG_fail;
30282 swig_obj[0] = args;
30283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30284 if (!SWIG_IsOK(res1)) {
30285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30286 }
30287 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30288 {
30289 PyThreadState* __tstate = wxPyBeginAllowThreads();
30290 delete arg1;
30291
30292 wxPyEndAllowThreads(__tstate);
30293 if (PyErr_Occurred()) SWIG_fail;
30294 }
30295 resultobj = SWIG_Py_Void();
30296 return resultobj;
30297 fail:
30298 return NULL;
30299 }
30300
30301
30302 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30303 PyObject *resultobj = 0;
30304 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30305 wxDataFormatId arg2 ;
30306 bool result;
30307 void *argp1 = 0 ;
30308 int res1 = 0 ;
30309 int val2 ;
30310 int ecode2 = 0 ;
30311
30312 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30314 if (!SWIG_IsOK(res1)) {
30315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30316 }
30317 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30318 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30319 if (!SWIG_IsOK(ecode2)) {
30320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30321 }
30322 arg2 = static_cast< wxDataFormatId >(val2);
30323 {
30324 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 {
30330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30331 }
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30339 PyObject *resultobj = 0;
30340 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30341 wxDataFormatId arg2 ;
30342 bool result;
30343 void *argp1 = 0 ;
30344 int res1 = 0 ;
30345 int val2 ;
30346 int ecode2 = 0 ;
30347
30348 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30350 if (!SWIG_IsOK(res1)) {
30351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30352 }
30353 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30354 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30355 if (!SWIG_IsOK(ecode2)) {
30356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30357 }
30358 arg2 = static_cast< wxDataFormatId >(val2);
30359 {
30360 PyThreadState* __tstate = wxPyBeginAllowThreads();
30361 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30362 wxPyEndAllowThreads(__tstate);
30363 if (PyErr_Occurred()) SWIG_fail;
30364 }
30365 {
30366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30367 }
30368 return resultobj;
30369 fail:
30370 return NULL;
30371 }
30372
30373
30374 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30375 PyObject *resultobj = 0;
30376 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30377 wxDataFormat *arg2 = 0 ;
30378 bool result;
30379 void *argp1 = 0 ;
30380 int res1 = 0 ;
30381 void *argp2 = 0 ;
30382 int res2 = 0 ;
30383
30384 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30386 if (!SWIG_IsOK(res1)) {
30387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30388 }
30389 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30390 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30391 if (!SWIG_IsOK(res2)) {
30392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30393 }
30394 if (!argp2) {
30395 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30396 }
30397 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30401 wxPyEndAllowThreads(__tstate);
30402 if (PyErr_Occurred()) SWIG_fail;
30403 }
30404 {
30405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30406 }
30407 return resultobj;
30408 fail:
30409 return NULL;
30410 }
30411
30412
30413 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30414 int argc;
30415 PyObject *argv[3];
30416
30417 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30418 --argc;
30419 if (argc == 2) {
30420 int _v = 0;
30421 {
30422 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30423 _v = SWIG_CheckState(res);
30424 }
30425 if (!_v) goto check_1;
30426 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30427 }
30428 check_1:
30429
30430 if (argc == 2) {
30431 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30432 }
30433
30434 fail:
30435 Py_INCREF(Py_NotImplemented);
30436 return Py_NotImplemented;
30437 }
30438
30439
30440 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30441 PyObject *resultobj = 0;
30442 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30443 wxDataFormat *arg2 = 0 ;
30444 bool result;
30445 void *argp1 = 0 ;
30446 int res1 = 0 ;
30447 void *argp2 = 0 ;
30448 int res2 = 0 ;
30449
30450 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30452 if (!SWIG_IsOK(res1)) {
30453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30454 }
30455 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30456 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30457 if (!SWIG_IsOK(res2)) {
30458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30459 }
30460 if (!argp2) {
30461 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30462 }
30463 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30464 {
30465 PyThreadState* __tstate = wxPyBeginAllowThreads();
30466 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30467 wxPyEndAllowThreads(__tstate);
30468 if (PyErr_Occurred()) SWIG_fail;
30469 }
30470 {
30471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30472 }
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30480 int argc;
30481 PyObject *argv[3];
30482
30483 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30484 --argc;
30485 if (argc == 2) {
30486 int _v = 0;
30487 {
30488 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30489 _v = SWIG_CheckState(res);
30490 }
30491 if (!_v) goto check_1;
30492 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30493 }
30494 check_1:
30495
30496 if (argc == 2) {
30497 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30498 }
30499
30500 fail:
30501 Py_INCREF(Py_NotImplemented);
30502 return Py_NotImplemented;
30503 }
30504
30505
30506 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30507 PyObject *resultobj = 0;
30508 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30509 wxDataFormatId arg2 ;
30510 void *argp1 = 0 ;
30511 int res1 = 0 ;
30512 int val2 ;
30513 int ecode2 = 0 ;
30514 PyObject * obj0 = 0 ;
30515 PyObject * obj1 = 0 ;
30516 char * kwnames[] = {
30517 (char *) "self",(char *) "format", NULL
30518 };
30519
30520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30522 if (!SWIG_IsOK(res1)) {
30523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30524 }
30525 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30526 ecode2 = SWIG_AsVal_int(obj1, &val2);
30527 if (!SWIG_IsOK(ecode2)) {
30528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30529 }
30530 arg2 = static_cast< wxDataFormatId >(val2);
30531 {
30532 PyThreadState* __tstate = wxPyBeginAllowThreads();
30533 (arg1)->SetType(arg2);
30534 wxPyEndAllowThreads(__tstate);
30535 if (PyErr_Occurred()) SWIG_fail;
30536 }
30537 resultobj = SWIG_Py_Void();
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30545 PyObject *resultobj = 0;
30546 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30547 wxDataFormatId result;
30548 void *argp1 = 0 ;
30549 int res1 = 0 ;
30550 PyObject *swig_obj[1] ;
30551
30552 if (!args) SWIG_fail;
30553 swig_obj[0] = args;
30554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30555 if (!SWIG_IsOK(res1)) {
30556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30557 }
30558 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30559 {
30560 PyThreadState* __tstate = wxPyBeginAllowThreads();
30561 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30562 wxPyEndAllowThreads(__tstate);
30563 if (PyErr_Occurred()) SWIG_fail;
30564 }
30565 resultobj = SWIG_From_int(static_cast< int >(result));
30566 return resultobj;
30567 fail:
30568 return NULL;
30569 }
30570
30571
30572 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30573 PyObject *resultobj = 0;
30574 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30575 wxString result;
30576 void *argp1 = 0 ;
30577 int res1 = 0 ;
30578 PyObject *swig_obj[1] ;
30579
30580 if (!args) SWIG_fail;
30581 swig_obj[0] = args;
30582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30583 if (!SWIG_IsOK(res1)) {
30584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30585 }
30586 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30587 {
30588 PyThreadState* __tstate = wxPyBeginAllowThreads();
30589 result = ((wxDataFormat const *)arg1)->GetId();
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 {
30594 #if wxUSE_UNICODE
30595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30596 #else
30597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30598 #endif
30599 }
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30607 PyObject *resultobj = 0;
30608 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30609 wxString *arg2 = 0 ;
30610 void *argp1 = 0 ;
30611 int res1 = 0 ;
30612 bool temp2 = false ;
30613 PyObject * obj0 = 0 ;
30614 PyObject * obj1 = 0 ;
30615 char * kwnames[] = {
30616 (char *) "self",(char *) "format", NULL
30617 };
30618
30619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30621 if (!SWIG_IsOK(res1)) {
30622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30623 }
30624 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30625 {
30626 arg2 = wxString_in_helper(obj1);
30627 if (arg2 == NULL) SWIG_fail;
30628 temp2 = true;
30629 }
30630 {
30631 PyThreadState* __tstate = wxPyBeginAllowThreads();
30632 (arg1)->SetId((wxString const &)*arg2);
30633 wxPyEndAllowThreads(__tstate);
30634 if (PyErr_Occurred()) SWIG_fail;
30635 }
30636 resultobj = SWIG_Py_Void();
30637 {
30638 if (temp2)
30639 delete arg2;
30640 }
30641 return resultobj;
30642 fail:
30643 {
30644 if (temp2)
30645 delete arg2;
30646 }
30647 return NULL;
30648 }
30649
30650
30651 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30652 PyObject *obj;
30653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30654 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30655 return SWIG_Py_Void();
30656 }
30657
30658 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30659 return SWIG_Python_InitShadowInstance(args);
30660 }
30661
30662 SWIGINTERN int FormatInvalid_set(PyObject *) {
30663 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30664 return 1;
30665 }
30666
30667
30668 SWIGINTERN PyObject *FormatInvalid_get(void) {
30669 PyObject *pyobj = 0;
30670
30671 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30672 return pyobj;
30673 }
30674
30675
30676 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30677 PyObject *resultobj = 0;
30678 wxDataObject *arg1 = (wxDataObject *) 0 ;
30679 void *argp1 = 0 ;
30680 int res1 = 0 ;
30681 PyObject *swig_obj[1] ;
30682
30683 if (!args) SWIG_fail;
30684 swig_obj[0] = args;
30685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30686 if (!SWIG_IsOK(res1)) {
30687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30688 }
30689 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30690 {
30691 PyThreadState* __tstate = wxPyBeginAllowThreads();
30692 delete arg1;
30693
30694 wxPyEndAllowThreads(__tstate);
30695 if (PyErr_Occurred()) SWIG_fail;
30696 }
30697 resultobj = SWIG_Py_Void();
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30705 PyObject *resultobj = 0;
30706 wxDataObject *arg1 = (wxDataObject *) 0 ;
30707 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30708 SwigValueWrapper<wxDataFormat > result;
30709 void *argp1 = 0 ;
30710 int res1 = 0 ;
30711 int val2 ;
30712 int ecode2 = 0 ;
30713 PyObject * obj0 = 0 ;
30714 PyObject * obj1 = 0 ;
30715 char * kwnames[] = {
30716 (char *) "self",(char *) "dir", NULL
30717 };
30718
30719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30721 if (!SWIG_IsOK(res1)) {
30722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30723 }
30724 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30725 if (obj1) {
30726 ecode2 = SWIG_AsVal_int(obj1, &val2);
30727 if (!SWIG_IsOK(ecode2)) {
30728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30729 }
30730 arg2 = static_cast< wxDataObject::Direction >(val2);
30731 }
30732 {
30733 PyThreadState* __tstate = wxPyBeginAllowThreads();
30734 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30735 wxPyEndAllowThreads(__tstate);
30736 if (PyErr_Occurred()) SWIG_fail;
30737 }
30738 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30739 return resultobj;
30740 fail:
30741 return NULL;
30742 }
30743
30744
30745 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30746 PyObject *resultobj = 0;
30747 wxDataObject *arg1 = (wxDataObject *) 0 ;
30748 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30749 size_t result;
30750 void *argp1 = 0 ;
30751 int res1 = 0 ;
30752 int val2 ;
30753 int ecode2 = 0 ;
30754 PyObject * obj0 = 0 ;
30755 PyObject * obj1 = 0 ;
30756 char * kwnames[] = {
30757 (char *) "self",(char *) "dir", NULL
30758 };
30759
30760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30762 if (!SWIG_IsOK(res1)) {
30763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30764 }
30765 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30766 if (obj1) {
30767 ecode2 = SWIG_AsVal_int(obj1, &val2);
30768 if (!SWIG_IsOK(ecode2)) {
30769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30770 }
30771 arg2 = static_cast< wxDataObject::Direction >(val2);
30772 }
30773 {
30774 PyThreadState* __tstate = wxPyBeginAllowThreads();
30775 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30776 wxPyEndAllowThreads(__tstate);
30777 if (PyErr_Occurred()) SWIG_fail;
30778 }
30779 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30780 return resultobj;
30781 fail:
30782 return NULL;
30783 }
30784
30785
30786 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30787 PyObject *resultobj = 0;
30788 wxDataObject *arg1 = (wxDataObject *) 0 ;
30789 wxDataFormat *arg2 = 0 ;
30790 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30791 bool result;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 void *argp2 = 0 ;
30795 int res2 = 0 ;
30796 int val3 ;
30797 int ecode3 = 0 ;
30798 PyObject * obj0 = 0 ;
30799 PyObject * obj1 = 0 ;
30800 PyObject * obj2 = 0 ;
30801 char * kwnames[] = {
30802 (char *) "self",(char *) "format",(char *) "dir", NULL
30803 };
30804
30805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30807 if (!SWIG_IsOK(res1)) {
30808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30809 }
30810 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30811 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30812 if (!SWIG_IsOK(res2)) {
30813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30814 }
30815 if (!argp2) {
30816 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30817 }
30818 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30819 if (obj2) {
30820 ecode3 = SWIG_AsVal_int(obj2, &val3);
30821 if (!SWIG_IsOK(ecode3)) {
30822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30823 }
30824 arg3 = static_cast< wxDataObject::Direction >(val3);
30825 }
30826 {
30827 PyThreadState* __tstate = wxPyBeginAllowThreads();
30828 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30829 wxPyEndAllowThreads(__tstate);
30830 if (PyErr_Occurred()) SWIG_fail;
30831 }
30832 {
30833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30834 }
30835 return resultobj;
30836 fail:
30837 return NULL;
30838 }
30839
30840
30841 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30842 PyObject *resultobj = 0;
30843 wxDataObject *arg1 = (wxDataObject *) 0 ;
30844 wxDataFormat *arg2 = 0 ;
30845 size_t result;
30846 void *argp1 = 0 ;
30847 int res1 = 0 ;
30848 void *argp2 = 0 ;
30849 int res2 = 0 ;
30850 PyObject * obj0 = 0 ;
30851 PyObject * obj1 = 0 ;
30852 char * kwnames[] = {
30853 (char *) "self",(char *) "format", NULL
30854 };
30855
30856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30858 if (!SWIG_IsOK(res1)) {
30859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30860 }
30861 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30862 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30863 if (!SWIG_IsOK(res2)) {
30864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30865 }
30866 if (!argp2) {
30867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30868 }
30869 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30873 wxPyEndAllowThreads(__tstate);
30874 if (PyErr_Occurred()) SWIG_fail;
30875 }
30876 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30877 return resultobj;
30878 fail:
30879 return NULL;
30880 }
30881
30882
30883 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30884 PyObject *resultobj = 0;
30885 wxDataObject *arg1 = (wxDataObject *) 0 ;
30886 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30887 PyObject *result = 0 ;
30888 void *argp1 = 0 ;
30889 int res1 = 0 ;
30890 int val2 ;
30891 int ecode2 = 0 ;
30892 PyObject * obj0 = 0 ;
30893 PyObject * obj1 = 0 ;
30894 char * kwnames[] = {
30895 (char *) "self",(char *) "dir", NULL
30896 };
30897
30898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30900 if (!SWIG_IsOK(res1)) {
30901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30902 }
30903 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30904 if (obj1) {
30905 ecode2 = SWIG_AsVal_int(obj1, &val2);
30906 if (!SWIG_IsOK(ecode2)) {
30907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30908 }
30909 arg2 = static_cast< wxDataObject::Direction >(val2);
30910 }
30911 {
30912 PyThreadState* __tstate = wxPyBeginAllowThreads();
30913 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30914 wxPyEndAllowThreads(__tstate);
30915 if (PyErr_Occurred()) SWIG_fail;
30916 }
30917 resultobj = result;
30918 return resultobj;
30919 fail:
30920 return NULL;
30921 }
30922
30923
30924 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30925 PyObject *resultobj = 0;
30926 wxDataObject *arg1 = (wxDataObject *) 0 ;
30927 wxDataFormat *arg2 = 0 ;
30928 PyObject *result = 0 ;
30929 void *argp1 = 0 ;
30930 int res1 = 0 ;
30931 void *argp2 = 0 ;
30932 int res2 = 0 ;
30933 PyObject * obj0 = 0 ;
30934 PyObject * obj1 = 0 ;
30935 char * kwnames[] = {
30936 (char *) "self",(char *) "format", NULL
30937 };
30938
30939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) 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_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
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_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30948 }
30949 if (!argp2) {
30950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30951 }
30952 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30953 {
30954 PyThreadState* __tstate = wxPyBeginAllowThreads();
30955 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30956 wxPyEndAllowThreads(__tstate);
30957 if (PyErr_Occurred()) SWIG_fail;
30958 }
30959 resultobj = result;
30960 return resultobj;
30961 fail:
30962 return NULL;
30963 }
30964
30965
30966 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30967 PyObject *resultobj = 0;
30968 wxDataObject *arg1 = (wxDataObject *) 0 ;
30969 wxDataFormat *arg2 = 0 ;
30970 PyObject *arg3 = (PyObject *) 0 ;
30971 bool result;
30972 void *argp1 = 0 ;
30973 int res1 = 0 ;
30974 void *argp2 = 0 ;
30975 int res2 = 0 ;
30976 PyObject * obj0 = 0 ;
30977 PyObject * obj1 = 0 ;
30978 PyObject * obj2 = 0 ;
30979 char * kwnames[] = {
30980 (char *) "self",(char *) "format",(char *) "data", NULL
30981 };
30982
30983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30985 if (!SWIG_IsOK(res1)) {
30986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30987 }
30988 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30989 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30990 if (!SWIG_IsOK(res2)) {
30991 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30992 }
30993 if (!argp2) {
30994 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30995 }
30996 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30997 arg3 = obj2;
30998 {
30999 PyThreadState* __tstate = wxPyBeginAllowThreads();
31000 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31001 wxPyEndAllowThreads(__tstate);
31002 if (PyErr_Occurred()) SWIG_fail;
31003 }
31004 {
31005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31006 }
31007 return resultobj;
31008 fail:
31009 return NULL;
31010 }
31011
31012
31013 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31014 PyObject *obj;
31015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31016 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31017 return SWIG_Py_Void();
31018 }
31019
31020 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj = 0;
31022 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31023 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31024 wxDataObjectSimple *result = 0 ;
31025 void *argp1 = 0 ;
31026 int res1 = 0 ;
31027 PyObject * obj0 = 0 ;
31028 char * kwnames[] = {
31029 (char *) "format", NULL
31030 };
31031
31032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31033 if (obj0) {
31034 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31035 if (!SWIG_IsOK(res1)) {
31036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31037 }
31038 if (!argp1) {
31039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31040 }
31041 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31042 }
31043 {
31044 PyThreadState* __tstate = wxPyBeginAllowThreads();
31045 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31046 wxPyEndAllowThreads(__tstate);
31047 if (PyErr_Occurred()) SWIG_fail;
31048 }
31049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31050 return resultobj;
31051 fail:
31052 return NULL;
31053 }
31054
31055
31056 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31057 PyObject *resultobj = 0;
31058 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31059 wxDataFormat *result = 0 ;
31060 void *argp1 = 0 ;
31061 int res1 = 0 ;
31062 PyObject *swig_obj[1] ;
31063
31064 if (!args) SWIG_fail;
31065 swig_obj[0] = args;
31066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31067 if (!SWIG_IsOK(res1)) {
31068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31069 }
31070 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31071 {
31072 PyThreadState* __tstate = wxPyBeginAllowThreads();
31073 {
31074 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31075 result = (wxDataFormat *) &_result_ref;
31076 }
31077 wxPyEndAllowThreads(__tstate);
31078 if (PyErr_Occurred()) SWIG_fail;
31079 }
31080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31081 return resultobj;
31082 fail:
31083 return NULL;
31084 }
31085
31086
31087 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31088 PyObject *resultobj = 0;
31089 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31090 wxDataFormat *arg2 = 0 ;
31091 void *argp1 = 0 ;
31092 int res1 = 0 ;
31093 void *argp2 = 0 ;
31094 int res2 = 0 ;
31095 PyObject * obj0 = 0 ;
31096 PyObject * obj1 = 0 ;
31097 char * kwnames[] = {
31098 (char *) "self",(char *) "format", NULL
31099 };
31100
31101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31103 if (!SWIG_IsOK(res1)) {
31104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31105 }
31106 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31107 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31108 if (!SWIG_IsOK(res2)) {
31109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31110 }
31111 if (!argp2) {
31112 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31113 }
31114 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31115 {
31116 PyThreadState* __tstate = wxPyBeginAllowThreads();
31117 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31118 wxPyEndAllowThreads(__tstate);
31119 if (PyErr_Occurred()) SWIG_fail;
31120 }
31121 resultobj = SWIG_Py_Void();
31122 return resultobj;
31123 fail:
31124 return NULL;
31125 }
31126
31127
31128 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31129 PyObject *resultobj = 0;
31130 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31131 size_t result;
31132 void *argp1 = 0 ;
31133 int res1 = 0 ;
31134 PyObject *swig_obj[1] ;
31135
31136 if (!args) SWIG_fail;
31137 swig_obj[0] = args;
31138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31139 if (!SWIG_IsOK(res1)) {
31140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31141 }
31142 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31157 PyObject *resultobj = 0;
31158 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31159 PyObject *result = 0 ;
31160 void *argp1 = 0 ;
31161 int res1 = 0 ;
31162 PyObject *swig_obj[1] ;
31163
31164 if (!args) SWIG_fail;
31165 swig_obj[0] = args;
31166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31167 if (!SWIG_IsOK(res1)) {
31168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31169 }
31170 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31171 {
31172 PyThreadState* __tstate = wxPyBeginAllowThreads();
31173 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31174 wxPyEndAllowThreads(__tstate);
31175 if (PyErr_Occurred()) SWIG_fail;
31176 }
31177 resultobj = result;
31178 return resultobj;
31179 fail:
31180 return NULL;
31181 }
31182
31183
31184 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31185 PyObject *resultobj = 0;
31186 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31187 PyObject *arg2 = (PyObject *) 0 ;
31188 bool result;
31189 void *argp1 = 0 ;
31190 int res1 = 0 ;
31191 PyObject * obj0 = 0 ;
31192 PyObject * obj1 = 0 ;
31193 char * kwnames[] = {
31194 (char *) "self",(char *) "data", NULL
31195 };
31196
31197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31199 if (!SWIG_IsOK(res1)) {
31200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31201 }
31202 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31203 arg2 = obj1;
31204 {
31205 PyThreadState* __tstate = wxPyBeginAllowThreads();
31206 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31207 wxPyEndAllowThreads(__tstate);
31208 if (PyErr_Occurred()) SWIG_fail;
31209 }
31210 {
31211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31212 }
31213 return resultobj;
31214 fail:
31215 return NULL;
31216 }
31217
31218
31219 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31220 PyObject *obj;
31221 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31222 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31223 return SWIG_Py_Void();
31224 }
31225
31226 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31227 return SWIG_Python_InitShadowInstance(args);
31228 }
31229
31230 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31231 PyObject *resultobj = 0;
31232 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31233 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31234 wxPyDataObjectSimple *result = 0 ;
31235 void *argp1 = 0 ;
31236 int res1 = 0 ;
31237 PyObject * obj0 = 0 ;
31238 char * kwnames[] = {
31239 (char *) "format", NULL
31240 };
31241
31242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31243 if (obj0) {
31244 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31245 if (!SWIG_IsOK(res1)) {
31246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31247 }
31248 if (!argp1) {
31249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31250 }
31251 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31252 }
31253 {
31254 PyThreadState* __tstate = wxPyBeginAllowThreads();
31255 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31256 wxPyEndAllowThreads(__tstate);
31257 if (PyErr_Occurred()) SWIG_fail;
31258 }
31259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31260 return resultobj;
31261 fail:
31262 return NULL;
31263 }
31264
31265
31266 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31267 PyObject *resultobj = 0;
31268 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31269 PyObject *arg2 = (PyObject *) 0 ;
31270 PyObject *arg3 = (PyObject *) 0 ;
31271 void *argp1 = 0 ;
31272 int res1 = 0 ;
31273 PyObject * obj0 = 0 ;
31274 PyObject * obj1 = 0 ;
31275 PyObject * obj2 = 0 ;
31276 char * kwnames[] = {
31277 (char *) "self",(char *) "self",(char *) "_class", NULL
31278 };
31279
31280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31282 if (!SWIG_IsOK(res1)) {
31283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31284 }
31285 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31286 arg2 = obj1;
31287 arg3 = obj2;
31288 {
31289 PyThreadState* __tstate = wxPyBeginAllowThreads();
31290 (arg1)->_setCallbackInfo(arg2,arg3);
31291 wxPyEndAllowThreads(__tstate);
31292 if (PyErr_Occurred()) SWIG_fail;
31293 }
31294 resultobj = SWIG_Py_Void();
31295 return resultobj;
31296 fail:
31297 return NULL;
31298 }
31299
31300
31301 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31302 PyObject *obj;
31303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31304 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31305 return SWIG_Py_Void();
31306 }
31307
31308 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31309 return SWIG_Python_InitShadowInstance(args);
31310 }
31311
31312 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31313 PyObject *resultobj = 0;
31314 wxDataObjectComposite *result = 0 ;
31315
31316 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31317 {
31318 PyThreadState* __tstate = wxPyBeginAllowThreads();
31319 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31320 wxPyEndAllowThreads(__tstate);
31321 if (PyErr_Occurred()) SWIG_fail;
31322 }
31323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31324 return resultobj;
31325 fail:
31326 return NULL;
31327 }
31328
31329
31330 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31331 PyObject *resultobj = 0;
31332 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31333 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31334 bool arg3 = (bool) false ;
31335 void *argp1 = 0 ;
31336 int res1 = 0 ;
31337 int res2 = 0 ;
31338 bool val3 ;
31339 int ecode3 = 0 ;
31340 PyObject * obj0 = 0 ;
31341 PyObject * obj1 = 0 ;
31342 PyObject * obj2 = 0 ;
31343 char * kwnames[] = {
31344 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31345 };
31346
31347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31349 if (!SWIG_IsOK(res1)) {
31350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31351 }
31352 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31353 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31354 if (!SWIG_IsOK(res2)) {
31355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31356 }
31357 if (obj2) {
31358 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31359 if (!SWIG_IsOK(ecode3)) {
31360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31361 }
31362 arg3 = static_cast< bool >(val3);
31363 }
31364 {
31365 PyThreadState* __tstate = wxPyBeginAllowThreads();
31366 (arg1)->Add(arg2,arg3);
31367 wxPyEndAllowThreads(__tstate);
31368 if (PyErr_Occurred()) SWIG_fail;
31369 }
31370 resultobj = SWIG_Py_Void();
31371 return resultobj;
31372 fail:
31373 return NULL;
31374 }
31375
31376
31377 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31378 PyObject *resultobj = 0;
31379 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31380 SwigValueWrapper<wxDataFormat > result;
31381 void *argp1 = 0 ;
31382 int res1 = 0 ;
31383 PyObject *swig_obj[1] ;
31384
31385 if (!args) SWIG_fail;
31386 swig_obj[0] = args;
31387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31388 if (!SWIG_IsOK(res1)) {
31389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31390 }
31391 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31392 {
31393 PyThreadState* __tstate = wxPyBeginAllowThreads();
31394 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31395 wxPyEndAllowThreads(__tstate);
31396 if (PyErr_Occurred()) SWIG_fail;
31397 }
31398 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31399 return resultobj;
31400 fail:
31401 return NULL;
31402 }
31403
31404
31405 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31406 PyObject *obj;
31407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31408 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31409 return SWIG_Py_Void();
31410 }
31411
31412 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31413 return SWIG_Python_InitShadowInstance(args);
31414 }
31415
31416 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31417 PyObject *resultobj = 0;
31418 wxString const &arg1_defvalue = wxPyEmptyString ;
31419 wxString *arg1 = (wxString *) &arg1_defvalue ;
31420 wxTextDataObject *result = 0 ;
31421 bool temp1 = false ;
31422 PyObject * obj0 = 0 ;
31423 char * kwnames[] = {
31424 (char *) "text", NULL
31425 };
31426
31427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31428 if (obj0) {
31429 {
31430 arg1 = wxString_in_helper(obj0);
31431 if (arg1 == NULL) SWIG_fail;
31432 temp1 = true;
31433 }
31434 }
31435 {
31436 PyThreadState* __tstate = wxPyBeginAllowThreads();
31437 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31438 wxPyEndAllowThreads(__tstate);
31439 if (PyErr_Occurred()) SWIG_fail;
31440 }
31441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31442 {
31443 if (temp1)
31444 delete arg1;
31445 }
31446 return resultobj;
31447 fail:
31448 {
31449 if (temp1)
31450 delete arg1;
31451 }
31452 return NULL;
31453 }
31454
31455
31456 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31457 PyObject *resultobj = 0;
31458 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31459 size_t result;
31460 void *argp1 = 0 ;
31461 int res1 = 0 ;
31462 PyObject *swig_obj[1] ;
31463
31464 if (!args) SWIG_fail;
31465 swig_obj[0] = args;
31466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31467 if (!SWIG_IsOK(res1)) {
31468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31469 }
31470 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31471 {
31472 PyThreadState* __tstate = wxPyBeginAllowThreads();
31473 result = (size_t)(arg1)->GetTextLength();
31474 wxPyEndAllowThreads(__tstate);
31475 if (PyErr_Occurred()) SWIG_fail;
31476 }
31477 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31478 return resultobj;
31479 fail:
31480 return NULL;
31481 }
31482
31483
31484 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31485 PyObject *resultobj = 0;
31486 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31487 wxString result;
31488 void *argp1 = 0 ;
31489 int res1 = 0 ;
31490 PyObject *swig_obj[1] ;
31491
31492 if (!args) SWIG_fail;
31493 swig_obj[0] = args;
31494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31495 if (!SWIG_IsOK(res1)) {
31496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31497 }
31498 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31499 {
31500 PyThreadState* __tstate = wxPyBeginAllowThreads();
31501 result = (arg1)->GetText();
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 {
31506 #if wxUSE_UNICODE
31507 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31508 #else
31509 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31510 #endif
31511 }
31512 return resultobj;
31513 fail:
31514 return NULL;
31515 }
31516
31517
31518 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31519 PyObject *resultobj = 0;
31520 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31521 wxString *arg2 = 0 ;
31522 void *argp1 = 0 ;
31523 int res1 = 0 ;
31524 bool temp2 = false ;
31525 PyObject * obj0 = 0 ;
31526 PyObject * obj1 = 0 ;
31527 char * kwnames[] = {
31528 (char *) "self",(char *) "text", NULL
31529 };
31530
31531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31533 if (!SWIG_IsOK(res1)) {
31534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31535 }
31536 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31537 {
31538 arg2 = wxString_in_helper(obj1);
31539 if (arg2 == NULL) SWIG_fail;
31540 temp2 = true;
31541 }
31542 {
31543 PyThreadState* __tstate = wxPyBeginAllowThreads();
31544 (arg1)->SetText((wxString const &)*arg2);
31545 wxPyEndAllowThreads(__tstate);
31546 if (PyErr_Occurred()) SWIG_fail;
31547 }
31548 resultobj = SWIG_Py_Void();
31549 {
31550 if (temp2)
31551 delete arg2;
31552 }
31553 return resultobj;
31554 fail:
31555 {
31556 if (temp2)
31557 delete arg2;
31558 }
31559 return NULL;
31560 }
31561
31562
31563 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31564 PyObject *obj;
31565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31566 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31567 return SWIG_Py_Void();
31568 }
31569
31570 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31571 return SWIG_Python_InitShadowInstance(args);
31572 }
31573
31574 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31575 PyObject *resultobj = 0;
31576 wxString const &arg1_defvalue = wxPyEmptyString ;
31577 wxString *arg1 = (wxString *) &arg1_defvalue ;
31578 wxPyTextDataObject *result = 0 ;
31579 bool temp1 = false ;
31580 PyObject * obj0 = 0 ;
31581 char * kwnames[] = {
31582 (char *) "text", NULL
31583 };
31584
31585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31586 if (obj0) {
31587 {
31588 arg1 = wxString_in_helper(obj0);
31589 if (arg1 == NULL) SWIG_fail;
31590 temp1 = true;
31591 }
31592 }
31593 {
31594 PyThreadState* __tstate = wxPyBeginAllowThreads();
31595 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31596 wxPyEndAllowThreads(__tstate);
31597 if (PyErr_Occurred()) SWIG_fail;
31598 }
31599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31600 {
31601 if (temp1)
31602 delete arg1;
31603 }
31604 return resultobj;
31605 fail:
31606 {
31607 if (temp1)
31608 delete arg1;
31609 }
31610 return NULL;
31611 }
31612
31613
31614 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31615 PyObject *resultobj = 0;
31616 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31617 PyObject *arg2 = (PyObject *) 0 ;
31618 PyObject *arg3 = (PyObject *) 0 ;
31619 void *argp1 = 0 ;
31620 int res1 = 0 ;
31621 PyObject * obj0 = 0 ;
31622 PyObject * obj1 = 0 ;
31623 PyObject * obj2 = 0 ;
31624 char * kwnames[] = {
31625 (char *) "self",(char *) "self",(char *) "_class", NULL
31626 };
31627
31628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31630 if (!SWIG_IsOK(res1)) {
31631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31632 }
31633 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31634 arg2 = obj1;
31635 arg3 = obj2;
31636 {
31637 PyThreadState* __tstate = wxPyBeginAllowThreads();
31638 (arg1)->_setCallbackInfo(arg2,arg3);
31639 wxPyEndAllowThreads(__tstate);
31640 if (PyErr_Occurred()) SWIG_fail;
31641 }
31642 resultobj = SWIG_Py_Void();
31643 return resultobj;
31644 fail:
31645 return NULL;
31646 }
31647
31648
31649 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31650 PyObject *obj;
31651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31652 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31653 return SWIG_Py_Void();
31654 }
31655
31656 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31657 return SWIG_Python_InitShadowInstance(args);
31658 }
31659
31660 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31661 PyObject *resultobj = 0;
31662 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31663 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31664 wxBitmapDataObject *result = 0 ;
31665 void *argp1 = 0 ;
31666 int res1 = 0 ;
31667 PyObject * obj0 = 0 ;
31668 char * kwnames[] = {
31669 (char *) "bitmap", NULL
31670 };
31671
31672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31673 if (obj0) {
31674 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31675 if (!SWIG_IsOK(res1)) {
31676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31677 }
31678 if (!argp1) {
31679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31680 }
31681 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31682 }
31683 {
31684 PyThreadState* __tstate = wxPyBeginAllowThreads();
31685 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31686 wxPyEndAllowThreads(__tstate);
31687 if (PyErr_Occurred()) SWIG_fail;
31688 }
31689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31690 return resultobj;
31691 fail:
31692 return NULL;
31693 }
31694
31695
31696 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31697 PyObject *resultobj = 0;
31698 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31699 wxBitmap result;
31700 void *argp1 = 0 ;
31701 int res1 = 0 ;
31702 PyObject *swig_obj[1] ;
31703
31704 if (!args) SWIG_fail;
31705 swig_obj[0] = args;
31706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31707 if (!SWIG_IsOK(res1)) {
31708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31709 }
31710 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31711 {
31712 PyThreadState* __tstate = wxPyBeginAllowThreads();
31713 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31714 wxPyEndAllowThreads(__tstate);
31715 if (PyErr_Occurred()) SWIG_fail;
31716 }
31717 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31718 return resultobj;
31719 fail:
31720 return NULL;
31721 }
31722
31723
31724 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31725 PyObject *resultobj = 0;
31726 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31727 wxBitmap *arg2 = 0 ;
31728 void *argp1 = 0 ;
31729 int res1 = 0 ;
31730 void *argp2 = 0 ;
31731 int res2 = 0 ;
31732 PyObject * obj0 = 0 ;
31733 PyObject * obj1 = 0 ;
31734 char * kwnames[] = {
31735 (char *) "self",(char *) "bitmap", NULL
31736 };
31737
31738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31740 if (!SWIG_IsOK(res1)) {
31741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31742 }
31743 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31744 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31745 if (!SWIG_IsOK(res2)) {
31746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31747 }
31748 if (!argp2) {
31749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31750 }
31751 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31752 {
31753 PyThreadState* __tstate = wxPyBeginAllowThreads();
31754 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31755 wxPyEndAllowThreads(__tstate);
31756 if (PyErr_Occurred()) SWIG_fail;
31757 }
31758 resultobj = SWIG_Py_Void();
31759 return resultobj;
31760 fail:
31761 return NULL;
31762 }
31763
31764
31765 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31766 PyObject *obj;
31767 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31768 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31769 return SWIG_Py_Void();
31770 }
31771
31772 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31773 return SWIG_Python_InitShadowInstance(args);
31774 }
31775
31776 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31777 PyObject *resultobj = 0;
31778 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31779 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31780 wxPyBitmapDataObject *result = 0 ;
31781 void *argp1 = 0 ;
31782 int res1 = 0 ;
31783 PyObject * obj0 = 0 ;
31784 char * kwnames[] = {
31785 (char *) "bitmap", NULL
31786 };
31787
31788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31789 if (obj0) {
31790 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31791 if (!SWIG_IsOK(res1)) {
31792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31793 }
31794 if (!argp1) {
31795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31796 }
31797 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31798 }
31799 {
31800 PyThreadState* __tstate = wxPyBeginAllowThreads();
31801 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31802 wxPyEndAllowThreads(__tstate);
31803 if (PyErr_Occurred()) SWIG_fail;
31804 }
31805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31806 return resultobj;
31807 fail:
31808 return NULL;
31809 }
31810
31811
31812 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31813 PyObject *resultobj = 0;
31814 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31815 PyObject *arg2 = (PyObject *) 0 ;
31816 PyObject *arg3 = (PyObject *) 0 ;
31817 void *argp1 = 0 ;
31818 int res1 = 0 ;
31819 PyObject * obj0 = 0 ;
31820 PyObject * obj1 = 0 ;
31821 PyObject * obj2 = 0 ;
31822 char * kwnames[] = {
31823 (char *) "self",(char *) "self",(char *) "_class", NULL
31824 };
31825
31826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31828 if (!SWIG_IsOK(res1)) {
31829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31830 }
31831 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31832 arg2 = obj1;
31833 arg3 = obj2;
31834 {
31835 PyThreadState* __tstate = wxPyBeginAllowThreads();
31836 (arg1)->_setCallbackInfo(arg2,arg3);
31837 wxPyEndAllowThreads(__tstate);
31838 if (PyErr_Occurred()) SWIG_fail;
31839 }
31840 resultobj = SWIG_Py_Void();
31841 return resultobj;
31842 fail:
31843 return NULL;
31844 }
31845
31846
31847 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31848 PyObject *obj;
31849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31850 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31851 return SWIG_Py_Void();
31852 }
31853
31854 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31855 return SWIG_Python_InitShadowInstance(args);
31856 }
31857
31858 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31859 PyObject *resultobj = 0;
31860 wxFileDataObject *result = 0 ;
31861
31862 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31863 {
31864 PyThreadState* __tstate = wxPyBeginAllowThreads();
31865 result = (wxFileDataObject *)new wxFileDataObject();
31866 wxPyEndAllowThreads(__tstate);
31867 if (PyErr_Occurred()) SWIG_fail;
31868 }
31869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31870 return resultobj;
31871 fail:
31872 return NULL;
31873 }
31874
31875
31876 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31877 PyObject *resultobj = 0;
31878 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31879 wxArrayString *result = 0 ;
31880 void *argp1 = 0 ;
31881 int res1 = 0 ;
31882 PyObject *swig_obj[1] ;
31883
31884 if (!args) SWIG_fail;
31885 swig_obj[0] = args;
31886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31887 if (!SWIG_IsOK(res1)) {
31888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31889 }
31890 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31891 {
31892 PyThreadState* __tstate = wxPyBeginAllowThreads();
31893 {
31894 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31895 result = (wxArrayString *) &_result_ref;
31896 }
31897 wxPyEndAllowThreads(__tstate);
31898 if (PyErr_Occurred()) SWIG_fail;
31899 }
31900 {
31901 resultobj = wxArrayString2PyList_helper(*result);
31902 }
31903 return resultobj;
31904 fail:
31905 return NULL;
31906 }
31907
31908
31909 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31910 PyObject *resultobj = 0;
31911 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31912 wxString *arg2 = 0 ;
31913 void *argp1 = 0 ;
31914 int res1 = 0 ;
31915 bool temp2 = false ;
31916 PyObject * obj0 = 0 ;
31917 PyObject * obj1 = 0 ;
31918 char * kwnames[] = {
31919 (char *) "self",(char *) "filename", NULL
31920 };
31921
31922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31924 if (!SWIG_IsOK(res1)) {
31925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31926 }
31927 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31928 {
31929 arg2 = wxString_in_helper(obj1);
31930 if (arg2 == NULL) SWIG_fail;
31931 temp2 = true;
31932 }
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 (arg1)->AddFile((wxString const &)*arg2);
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 resultobj = SWIG_Py_Void();
31940 {
31941 if (temp2)
31942 delete arg2;
31943 }
31944 return resultobj;
31945 fail:
31946 {
31947 if (temp2)
31948 delete arg2;
31949 }
31950 return NULL;
31951 }
31952
31953
31954 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31955 PyObject *obj;
31956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31957 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31958 return SWIG_Py_Void();
31959 }
31960
31961 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31962 return SWIG_Python_InitShadowInstance(args);
31963 }
31964
31965 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31966 PyObject *resultobj = 0;
31967 wxDataFormat *arg1 = 0 ;
31968 wxCustomDataObject *result = 0 ;
31969 void *argp1 = 0 ;
31970 int res1 = 0 ;
31971
31972 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31974 if (!SWIG_IsOK(res1)) {
31975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31976 }
31977 if (!argp1) {
31978 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31979 }
31980 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31981 {
31982 PyThreadState* __tstate = wxPyBeginAllowThreads();
31983 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31984 wxPyEndAllowThreads(__tstate);
31985 if (PyErr_Occurred()) SWIG_fail;
31986 }
31987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31988 return resultobj;
31989 fail:
31990 return NULL;
31991 }
31992
31993
31994 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31995 PyObject *resultobj = 0;
31996 wxString *arg1 = 0 ;
31997 wxCustomDataObject *result = 0 ;
31998 bool temp1 = false ;
31999
32000 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32001 {
32002 arg1 = wxString_in_helper(swig_obj[0]);
32003 if (arg1 == NULL) SWIG_fail;
32004 temp1 = true;
32005 }
32006 {
32007 PyThreadState* __tstate = wxPyBeginAllowThreads();
32008 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32009 wxPyEndAllowThreads(__tstate);
32010 if (PyErr_Occurred()) SWIG_fail;
32011 }
32012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32013 {
32014 if (temp1)
32015 delete arg1;
32016 }
32017 return resultobj;
32018 fail:
32019 {
32020 if (temp1)
32021 delete arg1;
32022 }
32023 return NULL;
32024 }
32025
32026
32027 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32028 PyObject *resultobj = 0;
32029 wxCustomDataObject *result = 0 ;
32030
32031 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32032 {
32033 PyThreadState* __tstate = wxPyBeginAllowThreads();
32034 result = (wxCustomDataObject *)new wxCustomDataObject();
32035 wxPyEndAllowThreads(__tstate);
32036 if (PyErr_Occurred()) SWIG_fail;
32037 }
32038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32039 return resultobj;
32040 fail:
32041 return NULL;
32042 }
32043
32044
32045 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32046 int argc;
32047 PyObject *argv[2];
32048
32049 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32050 --argc;
32051 if (argc == 0) {
32052 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32053 }
32054 if (argc == 1) {
32055 int _v = 0;
32056 {
32057 {
32058 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32059 }
32060 }
32061 if (!_v) goto check_2;
32062 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32063 }
32064 check_2:
32065
32066 if (argc == 1) {
32067 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32068 }
32069
32070 fail:
32071 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32072 return NULL;
32073 }
32074
32075
32076 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32077 PyObject *resultobj = 0;
32078 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32079 PyObject *arg2 = (PyObject *) 0 ;
32080 bool result;
32081 void *argp1 = 0 ;
32082 int res1 = 0 ;
32083 PyObject * obj0 = 0 ;
32084 PyObject * obj1 = 0 ;
32085 char * kwnames[] = {
32086 (char *) "self",(char *) "data", NULL
32087 };
32088
32089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32091 if (!SWIG_IsOK(res1)) {
32092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32093 }
32094 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32095 arg2 = obj1;
32096 {
32097 PyThreadState* __tstate = wxPyBeginAllowThreads();
32098 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32099 wxPyEndAllowThreads(__tstate);
32100 if (PyErr_Occurred()) SWIG_fail;
32101 }
32102 {
32103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32104 }
32105 return resultobj;
32106 fail:
32107 return NULL;
32108 }
32109
32110
32111 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32112 PyObject *resultobj = 0;
32113 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32114 size_t result;
32115 void *argp1 = 0 ;
32116 int res1 = 0 ;
32117 PyObject *swig_obj[1] ;
32118
32119 if (!args) SWIG_fail;
32120 swig_obj[0] = args;
32121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32122 if (!SWIG_IsOK(res1)) {
32123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32124 }
32125 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32126 {
32127 PyThreadState* __tstate = wxPyBeginAllowThreads();
32128 result = (size_t)(arg1)->GetSize();
32129 wxPyEndAllowThreads(__tstate);
32130 if (PyErr_Occurred()) SWIG_fail;
32131 }
32132 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32133 return resultobj;
32134 fail:
32135 return NULL;
32136 }
32137
32138
32139 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32140 PyObject *resultobj = 0;
32141 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32142 PyObject *result = 0 ;
32143 void *argp1 = 0 ;
32144 int res1 = 0 ;
32145 PyObject *swig_obj[1] ;
32146
32147 if (!args) SWIG_fail;
32148 swig_obj[0] = args;
32149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32150 if (!SWIG_IsOK(res1)) {
32151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32152 }
32153 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32154 {
32155 PyThreadState* __tstate = wxPyBeginAllowThreads();
32156 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32157 wxPyEndAllowThreads(__tstate);
32158 if (PyErr_Occurred()) SWIG_fail;
32159 }
32160 resultobj = result;
32161 return resultobj;
32162 fail:
32163 return NULL;
32164 }
32165
32166
32167 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32168 PyObject *obj;
32169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32170 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32171 return SWIG_Py_Void();
32172 }
32173
32174 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32175 return SWIG_Python_InitShadowInstance(args);
32176 }
32177
32178 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32179 PyObject *resultobj = 0;
32180 wxURLDataObject *result = 0 ;
32181
32182 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32183 {
32184 PyThreadState* __tstate = wxPyBeginAllowThreads();
32185 result = (wxURLDataObject *)new wxURLDataObject();
32186 wxPyEndAllowThreads(__tstate);
32187 if (PyErr_Occurred()) SWIG_fail;
32188 }
32189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32190 return resultobj;
32191 fail:
32192 return NULL;
32193 }
32194
32195
32196 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32197 PyObject *resultobj = 0;
32198 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32199 wxString result;
32200 void *argp1 = 0 ;
32201 int res1 = 0 ;
32202 PyObject *swig_obj[1] ;
32203
32204 if (!args) SWIG_fail;
32205 swig_obj[0] = args;
32206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32207 if (!SWIG_IsOK(res1)) {
32208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32209 }
32210 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32211 {
32212 PyThreadState* __tstate = wxPyBeginAllowThreads();
32213 result = (arg1)->GetURL();
32214 wxPyEndAllowThreads(__tstate);
32215 if (PyErr_Occurred()) SWIG_fail;
32216 }
32217 {
32218 #if wxUSE_UNICODE
32219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32220 #else
32221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32222 #endif
32223 }
32224 return resultobj;
32225 fail:
32226 return NULL;
32227 }
32228
32229
32230 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32231 PyObject *resultobj = 0;
32232 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32233 wxString *arg2 = 0 ;
32234 void *argp1 = 0 ;
32235 int res1 = 0 ;
32236 bool temp2 = false ;
32237 PyObject * obj0 = 0 ;
32238 PyObject * obj1 = 0 ;
32239 char * kwnames[] = {
32240 (char *) "self",(char *) "url", NULL
32241 };
32242
32243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32245 if (!SWIG_IsOK(res1)) {
32246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32247 }
32248 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32249 {
32250 arg2 = wxString_in_helper(obj1);
32251 if (arg2 == NULL) SWIG_fail;
32252 temp2 = true;
32253 }
32254 {
32255 PyThreadState* __tstate = wxPyBeginAllowThreads();
32256 (arg1)->SetURL((wxString const &)*arg2);
32257 wxPyEndAllowThreads(__tstate);
32258 if (PyErr_Occurred()) SWIG_fail;
32259 }
32260 resultobj = SWIG_Py_Void();
32261 {
32262 if (temp2)
32263 delete arg2;
32264 }
32265 return resultobj;
32266 fail:
32267 {
32268 if (temp2)
32269 delete arg2;
32270 }
32271 return NULL;
32272 }
32273
32274
32275 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32276 PyObject *obj;
32277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32278 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32279 return SWIG_Py_Void();
32280 }
32281
32282 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32283 return SWIG_Python_InitShadowInstance(args);
32284 }
32285
32286 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32287 PyObject *resultobj = 0;
32288 wxMetafileDataObject *result = 0 ;
32289
32290 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32291 {
32292 PyThreadState* __tstate = wxPyBeginAllowThreads();
32293 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32294 wxPyEndAllowThreads(__tstate);
32295 if (PyErr_Occurred()) SWIG_fail;
32296 }
32297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32298 return resultobj;
32299 fail:
32300 return NULL;
32301 }
32302
32303
32304 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32305 PyObject *resultobj = 0;
32306 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32307 wxMetafile *arg2 = 0 ;
32308 void *argp1 = 0 ;
32309 int res1 = 0 ;
32310 void *argp2 = 0 ;
32311 int res2 = 0 ;
32312 PyObject * obj0 = 0 ;
32313 PyObject * obj1 = 0 ;
32314 char * kwnames[] = {
32315 (char *) "self",(char *) "metafile", NULL
32316 };
32317
32318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32320 if (!SWIG_IsOK(res1)) {
32321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32322 }
32323 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32324 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32325 if (!SWIG_IsOK(res2)) {
32326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32327 }
32328 if (!argp2) {
32329 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32330 }
32331 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32332 {
32333 PyThreadState* __tstate = wxPyBeginAllowThreads();
32334 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32335 wxPyEndAllowThreads(__tstate);
32336 if (PyErr_Occurred()) SWIG_fail;
32337 }
32338 resultobj = SWIG_Py_Void();
32339 return resultobj;
32340 fail:
32341 return NULL;
32342 }
32343
32344
32345 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32346 PyObject *resultobj = 0;
32347 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32348 wxMetafile result;
32349 void *argp1 = 0 ;
32350 int res1 = 0 ;
32351 PyObject *swig_obj[1] ;
32352
32353 if (!args) SWIG_fail;
32354 swig_obj[0] = args;
32355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32356 if (!SWIG_IsOK(res1)) {
32357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32358 }
32359 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32360 {
32361 PyThreadState* __tstate = wxPyBeginAllowThreads();
32362 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32363 wxPyEndAllowThreads(__tstate);
32364 if (PyErr_Occurred()) SWIG_fail;
32365 }
32366 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32367 return resultobj;
32368 fail:
32369 return NULL;
32370 }
32371
32372
32373 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32374 PyObject *obj;
32375 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32376 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32377 return SWIG_Py_Void();
32378 }
32379
32380 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32381 return SWIG_Python_InitShadowInstance(args);
32382 }
32383
32384 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32385 PyObject *resultobj = 0;
32386 wxDragResult arg1 ;
32387 bool result;
32388 int val1 ;
32389 int ecode1 = 0 ;
32390 PyObject * obj0 = 0 ;
32391 char * kwnames[] = {
32392 (char *) "res", NULL
32393 };
32394
32395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32396 ecode1 = SWIG_AsVal_int(obj0, &val1);
32397 if (!SWIG_IsOK(ecode1)) {
32398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32399 }
32400 arg1 = static_cast< wxDragResult >(val1);
32401 {
32402 PyThreadState* __tstate = wxPyBeginAllowThreads();
32403 result = (bool)wxIsDragResultOk(arg1);
32404 wxPyEndAllowThreads(__tstate);
32405 if (PyErr_Occurred()) SWIG_fail;
32406 }
32407 {
32408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32409 }
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32417 PyObject *resultobj = 0;
32418 wxWindow *arg1 = (wxWindow *) 0 ;
32419 wxCursor const &arg2_defvalue = wxNullCursor ;
32420 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32421 wxCursor const &arg3_defvalue = wxNullCursor ;
32422 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32423 wxCursor const &arg4_defvalue = wxNullCursor ;
32424 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32425 wxPyDropSource *result = 0 ;
32426 void *argp1 = 0 ;
32427 int res1 = 0 ;
32428 void *argp2 = 0 ;
32429 int res2 = 0 ;
32430 void *argp3 = 0 ;
32431 int res3 = 0 ;
32432 void *argp4 = 0 ;
32433 int res4 = 0 ;
32434 PyObject * obj0 = 0 ;
32435 PyObject * obj1 = 0 ;
32436 PyObject * obj2 = 0 ;
32437 PyObject * obj3 = 0 ;
32438 char * kwnames[] = {
32439 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32440 };
32441
32442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32444 if (!SWIG_IsOK(res1)) {
32445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32446 }
32447 arg1 = reinterpret_cast< wxWindow * >(argp1);
32448 if (obj1) {
32449 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32450 if (!SWIG_IsOK(res2)) {
32451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32452 }
32453 if (!argp2) {
32454 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32455 }
32456 arg2 = reinterpret_cast< wxCursor * >(argp2);
32457 }
32458 if (obj2) {
32459 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32460 if (!SWIG_IsOK(res3)) {
32461 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32462 }
32463 if (!argp3) {
32464 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32465 }
32466 arg3 = reinterpret_cast< wxCursor * >(argp3);
32467 }
32468 if (obj3) {
32469 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32470 if (!SWIG_IsOK(res4)) {
32471 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32472 }
32473 if (!argp4) {
32474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32475 }
32476 arg4 = reinterpret_cast< wxCursor * >(argp4);
32477 }
32478 {
32479 PyThreadState* __tstate = wxPyBeginAllowThreads();
32480 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32481 wxPyEndAllowThreads(__tstate);
32482 if (PyErr_Occurred()) SWIG_fail;
32483 }
32484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32485 return resultobj;
32486 fail:
32487 return NULL;
32488 }
32489
32490
32491 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32492 PyObject *resultobj = 0;
32493 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32494 PyObject *arg2 = (PyObject *) 0 ;
32495 PyObject *arg3 = (PyObject *) 0 ;
32496 int arg4 ;
32497 void *argp1 = 0 ;
32498 int res1 = 0 ;
32499 int val4 ;
32500 int ecode4 = 0 ;
32501 PyObject * obj0 = 0 ;
32502 PyObject * obj1 = 0 ;
32503 PyObject * obj2 = 0 ;
32504 PyObject * obj3 = 0 ;
32505 char * kwnames[] = {
32506 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32507 };
32508
32509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32511 if (!SWIG_IsOK(res1)) {
32512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32513 }
32514 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32515 arg2 = obj1;
32516 arg3 = obj2;
32517 ecode4 = SWIG_AsVal_int(obj3, &val4);
32518 if (!SWIG_IsOK(ecode4)) {
32519 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32520 }
32521 arg4 = static_cast< int >(val4);
32522 {
32523 PyThreadState* __tstate = wxPyBeginAllowThreads();
32524 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32525 wxPyEndAllowThreads(__tstate);
32526 if (PyErr_Occurred()) SWIG_fail;
32527 }
32528 resultobj = SWIG_Py_Void();
32529 return resultobj;
32530 fail:
32531 return NULL;
32532 }
32533
32534
32535 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32536 PyObject *resultobj = 0;
32537 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32538 void *argp1 = 0 ;
32539 int res1 = 0 ;
32540 PyObject *swig_obj[1] ;
32541
32542 if (!args) SWIG_fail;
32543 swig_obj[0] = args;
32544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32545 if (!SWIG_IsOK(res1)) {
32546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32547 }
32548 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32549 {
32550 PyThreadState* __tstate = wxPyBeginAllowThreads();
32551 delete arg1;
32552
32553 wxPyEndAllowThreads(__tstate);
32554 if (PyErr_Occurred()) SWIG_fail;
32555 }
32556 resultobj = SWIG_Py_Void();
32557 return resultobj;
32558 fail:
32559 return NULL;
32560 }
32561
32562
32563 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32564 PyObject *resultobj = 0;
32565 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32566 wxDataObject *arg2 = 0 ;
32567 void *argp1 = 0 ;
32568 int res1 = 0 ;
32569 void *argp2 = 0 ;
32570 int res2 = 0 ;
32571 PyObject * obj0 = 0 ;
32572 PyObject * obj1 = 0 ;
32573 char * kwnames[] = {
32574 (char *) "self",(char *) "data", NULL
32575 };
32576
32577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32579 if (!SWIG_IsOK(res1)) {
32580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32581 }
32582 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32583 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32584 if (!SWIG_IsOK(res2)) {
32585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32586 }
32587 if (!argp2) {
32588 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32589 }
32590 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32591 {
32592 PyThreadState* __tstate = wxPyBeginAllowThreads();
32593 (arg1)->SetData(*arg2);
32594 wxPyEndAllowThreads(__tstate);
32595 if (PyErr_Occurred()) SWIG_fail;
32596 }
32597 resultobj = SWIG_Py_Void();
32598 return resultobj;
32599 fail:
32600 return NULL;
32601 }
32602
32603
32604 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32605 PyObject *resultobj = 0;
32606 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32607 wxDataObject *result = 0 ;
32608 void *argp1 = 0 ;
32609 int res1 = 0 ;
32610 PyObject *swig_obj[1] ;
32611
32612 if (!args) SWIG_fail;
32613 swig_obj[0] = args;
32614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32615 if (!SWIG_IsOK(res1)) {
32616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32617 }
32618 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32619 {
32620 PyThreadState* __tstate = wxPyBeginAllowThreads();
32621 result = (wxDataObject *)(arg1)->GetDataObject();
32622 wxPyEndAllowThreads(__tstate);
32623 if (PyErr_Occurred()) SWIG_fail;
32624 }
32625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32626 return resultobj;
32627 fail:
32628 return NULL;
32629 }
32630
32631
32632 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32633 PyObject *resultobj = 0;
32634 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32635 wxDragResult arg2 ;
32636 wxCursor *arg3 = 0 ;
32637 void *argp1 = 0 ;
32638 int res1 = 0 ;
32639 int val2 ;
32640 int ecode2 = 0 ;
32641 void *argp3 = 0 ;
32642 int res3 = 0 ;
32643 PyObject * obj0 = 0 ;
32644 PyObject * obj1 = 0 ;
32645 PyObject * obj2 = 0 ;
32646 char * kwnames[] = {
32647 (char *) "self",(char *) "res",(char *) "cursor", NULL
32648 };
32649
32650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32652 if (!SWIG_IsOK(res1)) {
32653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32654 }
32655 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32656 ecode2 = SWIG_AsVal_int(obj1, &val2);
32657 if (!SWIG_IsOK(ecode2)) {
32658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32659 }
32660 arg2 = static_cast< wxDragResult >(val2);
32661 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32662 if (!SWIG_IsOK(res3)) {
32663 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32664 }
32665 if (!argp3) {
32666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32667 }
32668 arg3 = reinterpret_cast< wxCursor * >(argp3);
32669 {
32670 PyThreadState* __tstate = wxPyBeginAllowThreads();
32671 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32672 wxPyEndAllowThreads(__tstate);
32673 if (PyErr_Occurred()) SWIG_fail;
32674 }
32675 resultobj = SWIG_Py_Void();
32676 return resultobj;
32677 fail:
32678 return NULL;
32679 }
32680
32681
32682 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32683 PyObject *resultobj = 0;
32684 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32685 int arg2 = (int) wxDrag_CopyOnly ;
32686 wxDragResult result;
32687 void *argp1 = 0 ;
32688 int res1 = 0 ;
32689 int val2 ;
32690 int ecode2 = 0 ;
32691 PyObject * obj0 = 0 ;
32692 PyObject * obj1 = 0 ;
32693 char * kwnames[] = {
32694 (char *) "self",(char *) "flags", NULL
32695 };
32696
32697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32699 if (!SWIG_IsOK(res1)) {
32700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32701 }
32702 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32703 if (obj1) {
32704 ecode2 = SWIG_AsVal_int(obj1, &val2);
32705 if (!SWIG_IsOK(ecode2)) {
32706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32707 }
32708 arg2 = static_cast< int >(val2);
32709 }
32710 {
32711 PyThreadState* __tstate = wxPyBeginAllowThreads();
32712 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32713 wxPyEndAllowThreads(__tstate);
32714 if (PyErr_Occurred()) SWIG_fail;
32715 }
32716 resultobj = SWIG_From_int(static_cast< int >(result));
32717 return resultobj;
32718 fail:
32719 return NULL;
32720 }
32721
32722
32723 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32724 PyObject *resultobj = 0;
32725 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32726 wxDragResult arg2 ;
32727 bool result;
32728 void *argp1 = 0 ;
32729 int res1 = 0 ;
32730 int val2 ;
32731 int ecode2 = 0 ;
32732 PyObject * obj0 = 0 ;
32733 PyObject * obj1 = 0 ;
32734 char * kwnames[] = {
32735 (char *) "self",(char *) "effect", NULL
32736 };
32737
32738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32740 if (!SWIG_IsOK(res1)) {
32741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32742 }
32743 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32744 ecode2 = SWIG_AsVal_int(obj1, &val2);
32745 if (!SWIG_IsOK(ecode2)) {
32746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32747 }
32748 arg2 = static_cast< wxDragResult >(val2);
32749 {
32750 PyThreadState* __tstate = wxPyBeginAllowThreads();
32751 result = (bool)(arg1)->GiveFeedback(arg2);
32752 wxPyEndAllowThreads(__tstate);
32753 if (PyErr_Occurred()) SWIG_fail;
32754 }
32755 {
32756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32757 }
32758 return resultobj;
32759 fail:
32760 return NULL;
32761 }
32762
32763
32764 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32765 PyObject *obj;
32766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32767 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32768 return SWIG_Py_Void();
32769 }
32770
32771 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32772 return SWIG_Python_InitShadowInstance(args);
32773 }
32774
32775 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32776 PyObject *resultobj = 0;
32777 wxDataObject *arg1 = (wxDataObject *) NULL ;
32778 wxPyDropTarget *result = 0 ;
32779 int res1 = 0 ;
32780 PyObject * obj0 = 0 ;
32781 char * kwnames[] = {
32782 (char *) "dataObject", NULL
32783 };
32784
32785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32786 if (obj0) {
32787 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32788 if (!SWIG_IsOK(res1)) {
32789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32790 }
32791 }
32792 {
32793 PyThreadState* __tstate = wxPyBeginAllowThreads();
32794 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32795 wxPyEndAllowThreads(__tstate);
32796 if (PyErr_Occurred()) SWIG_fail;
32797 }
32798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32799 return resultobj;
32800 fail:
32801 return NULL;
32802 }
32803
32804
32805 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32806 PyObject *resultobj = 0;
32807 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32808 PyObject *arg2 = (PyObject *) 0 ;
32809 PyObject *arg3 = (PyObject *) 0 ;
32810 void *argp1 = 0 ;
32811 int res1 = 0 ;
32812 PyObject * obj0 = 0 ;
32813 PyObject * obj1 = 0 ;
32814 PyObject * obj2 = 0 ;
32815 char * kwnames[] = {
32816 (char *) "self",(char *) "self",(char *) "_class", NULL
32817 };
32818
32819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32821 if (!SWIG_IsOK(res1)) {
32822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32823 }
32824 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32825 arg2 = obj1;
32826 arg3 = obj2;
32827 {
32828 PyThreadState* __tstate = wxPyBeginAllowThreads();
32829 (arg1)->_setCallbackInfo(arg2,arg3);
32830 wxPyEndAllowThreads(__tstate);
32831 if (PyErr_Occurred()) SWIG_fail;
32832 }
32833 resultobj = SWIG_Py_Void();
32834 return resultobj;
32835 fail:
32836 return NULL;
32837 }
32838
32839
32840 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32841 PyObject *resultobj = 0;
32842 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32843 void *argp1 = 0 ;
32844 int res1 = 0 ;
32845 PyObject *swig_obj[1] ;
32846
32847 if (!args) SWIG_fail;
32848 swig_obj[0] = args;
32849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32850 if (!SWIG_IsOK(res1)) {
32851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32852 }
32853 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32854 {
32855 PyThreadState* __tstate = wxPyBeginAllowThreads();
32856 delete arg1;
32857
32858 wxPyEndAllowThreads(__tstate);
32859 if (PyErr_Occurred()) SWIG_fail;
32860 }
32861 resultobj = SWIG_Py_Void();
32862 return resultobj;
32863 fail:
32864 return NULL;
32865 }
32866
32867
32868 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32869 PyObject *resultobj = 0;
32870 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32871 wxDataObject *result = 0 ;
32872 void *argp1 = 0 ;
32873 int res1 = 0 ;
32874 PyObject *swig_obj[1] ;
32875
32876 if (!args) SWIG_fail;
32877 swig_obj[0] = args;
32878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32879 if (!SWIG_IsOK(res1)) {
32880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32881 }
32882 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32883 {
32884 PyThreadState* __tstate = wxPyBeginAllowThreads();
32885 result = (wxDataObject *)(arg1)->GetDataObject();
32886 wxPyEndAllowThreads(__tstate);
32887 if (PyErr_Occurred()) SWIG_fail;
32888 }
32889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32890 return resultobj;
32891 fail:
32892 return NULL;
32893 }
32894
32895
32896 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32897 PyObject *resultobj = 0;
32898 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32899 wxDataObject *arg2 = (wxDataObject *) 0 ;
32900 void *argp1 = 0 ;
32901 int res1 = 0 ;
32902 int res2 = 0 ;
32903 PyObject * obj0 = 0 ;
32904 PyObject * obj1 = 0 ;
32905 char * kwnames[] = {
32906 (char *) "self",(char *) "dataObject", NULL
32907 };
32908
32909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32911 if (!SWIG_IsOK(res1)) {
32912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32913 }
32914 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32915 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32916 if (!SWIG_IsOK(res2)) {
32917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32918 }
32919 {
32920 PyThreadState* __tstate = wxPyBeginAllowThreads();
32921 (arg1)->SetDataObject(arg2);
32922 wxPyEndAllowThreads(__tstate);
32923 if (PyErr_Occurred()) SWIG_fail;
32924 }
32925 resultobj = SWIG_Py_Void();
32926 return resultobj;
32927 fail:
32928 return NULL;
32929 }
32930
32931
32932 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32933 PyObject *resultobj = 0;
32934 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32935 int arg2 ;
32936 int arg3 ;
32937 wxDragResult arg4 ;
32938 wxDragResult result;
32939 void *argp1 = 0 ;
32940 int res1 = 0 ;
32941 int val2 ;
32942 int ecode2 = 0 ;
32943 int val3 ;
32944 int ecode3 = 0 ;
32945 int val4 ;
32946 int ecode4 = 0 ;
32947 PyObject * obj0 = 0 ;
32948 PyObject * obj1 = 0 ;
32949 PyObject * obj2 = 0 ;
32950 PyObject * obj3 = 0 ;
32951 char * kwnames[] = {
32952 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
32953 };
32954
32955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32957 if (!SWIG_IsOK(res1)) {
32958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32959 }
32960 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32961 ecode2 = SWIG_AsVal_int(obj1, &val2);
32962 if (!SWIG_IsOK(ecode2)) {
32963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32964 }
32965 arg2 = static_cast< int >(val2);
32966 ecode3 = SWIG_AsVal_int(obj2, &val3);
32967 if (!SWIG_IsOK(ecode3)) {
32968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32969 }
32970 arg3 = static_cast< int >(val3);
32971 ecode4 = SWIG_AsVal_int(obj3, &val4);
32972 if (!SWIG_IsOK(ecode4)) {
32973 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32974 }
32975 arg4 = static_cast< wxDragResult >(val4);
32976 {
32977 PyThreadState* __tstate = wxPyBeginAllowThreads();
32978 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32979 wxPyEndAllowThreads(__tstate);
32980 if (PyErr_Occurred()) SWIG_fail;
32981 }
32982 resultobj = SWIG_From_int(static_cast< int >(result));
32983 return resultobj;
32984 fail:
32985 return NULL;
32986 }
32987
32988
32989 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32990 PyObject *resultobj = 0;
32991 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32992 int arg2 ;
32993 int arg3 ;
32994 wxDragResult arg4 ;
32995 wxDragResult result;
32996 void *argp1 = 0 ;
32997 int res1 = 0 ;
32998 int val2 ;
32999 int ecode2 = 0 ;
33000 int val3 ;
33001 int ecode3 = 0 ;
33002 int val4 ;
33003 int ecode4 = 0 ;
33004 PyObject * obj0 = 0 ;
33005 PyObject * obj1 = 0 ;
33006 PyObject * obj2 = 0 ;
33007 PyObject * obj3 = 0 ;
33008 char * kwnames[] = {
33009 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33010 };
33011
33012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33014 if (!SWIG_IsOK(res1)) {
33015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33016 }
33017 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33018 ecode2 = SWIG_AsVal_int(obj1, &val2);
33019 if (!SWIG_IsOK(ecode2)) {
33020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33021 }
33022 arg2 = static_cast< int >(val2);
33023 ecode3 = SWIG_AsVal_int(obj2, &val3);
33024 if (!SWIG_IsOK(ecode3)) {
33025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33026 }
33027 arg3 = static_cast< int >(val3);
33028 ecode4 = SWIG_AsVal_int(obj3, &val4);
33029 if (!SWIG_IsOK(ecode4)) {
33030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33031 }
33032 arg4 = static_cast< wxDragResult >(val4);
33033 {
33034 PyThreadState* __tstate = wxPyBeginAllowThreads();
33035 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33036 wxPyEndAllowThreads(__tstate);
33037 if (PyErr_Occurred()) SWIG_fail;
33038 }
33039 resultobj = SWIG_From_int(static_cast< int >(result));
33040 return resultobj;
33041 fail:
33042 return NULL;
33043 }
33044
33045
33046 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33047 PyObject *resultobj = 0;
33048 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33049 void *argp1 = 0 ;
33050 int res1 = 0 ;
33051 PyObject *swig_obj[1] ;
33052
33053 if (!args) SWIG_fail;
33054 swig_obj[0] = args;
33055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33056 if (!SWIG_IsOK(res1)) {
33057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33058 }
33059 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33060 {
33061 PyThreadState* __tstate = wxPyBeginAllowThreads();
33062 (arg1)->OnLeave();
33063 wxPyEndAllowThreads(__tstate);
33064 if (PyErr_Occurred()) SWIG_fail;
33065 }
33066 resultobj = SWIG_Py_Void();
33067 return resultobj;
33068 fail:
33069 return NULL;
33070 }
33071
33072
33073 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33074 PyObject *resultobj = 0;
33075 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33076 int arg2 ;
33077 int arg3 ;
33078 bool result;
33079 void *argp1 = 0 ;
33080 int res1 = 0 ;
33081 int val2 ;
33082 int ecode2 = 0 ;
33083 int val3 ;
33084 int ecode3 = 0 ;
33085 PyObject * obj0 = 0 ;
33086 PyObject * obj1 = 0 ;
33087 PyObject * obj2 = 0 ;
33088 char * kwnames[] = {
33089 (char *) "self",(char *) "x",(char *) "y", NULL
33090 };
33091
33092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33094 if (!SWIG_IsOK(res1)) {
33095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33096 }
33097 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33098 ecode2 = SWIG_AsVal_int(obj1, &val2);
33099 if (!SWIG_IsOK(ecode2)) {
33100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33101 }
33102 arg2 = static_cast< int >(val2);
33103 ecode3 = SWIG_AsVal_int(obj2, &val3);
33104 if (!SWIG_IsOK(ecode3)) {
33105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33106 }
33107 arg3 = static_cast< int >(val3);
33108 {
33109 PyThreadState* __tstate = wxPyBeginAllowThreads();
33110 result = (bool)(arg1)->OnDrop(arg2,arg3);
33111 wxPyEndAllowThreads(__tstate);
33112 if (PyErr_Occurred()) SWIG_fail;
33113 }
33114 {
33115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33116 }
33117 return resultobj;
33118 fail:
33119 return NULL;
33120 }
33121
33122
33123 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33124 PyObject *resultobj = 0;
33125 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33126 bool result;
33127 void *argp1 = 0 ;
33128 int res1 = 0 ;
33129 PyObject *swig_obj[1] ;
33130
33131 if (!args) SWIG_fail;
33132 swig_obj[0] = args;
33133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33134 if (!SWIG_IsOK(res1)) {
33135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33136 }
33137 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33138 {
33139 PyThreadState* __tstate = wxPyBeginAllowThreads();
33140 result = (bool)(arg1)->GetData();
33141 wxPyEndAllowThreads(__tstate);
33142 if (PyErr_Occurred()) SWIG_fail;
33143 }
33144 {
33145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33146 }
33147 return resultobj;
33148 fail:
33149 return NULL;
33150 }
33151
33152
33153 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33154 PyObject *resultobj = 0;
33155 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33156 wxDragResult arg2 ;
33157 void *argp1 = 0 ;
33158 int res1 = 0 ;
33159 int val2 ;
33160 int ecode2 = 0 ;
33161 PyObject * obj0 = 0 ;
33162 PyObject * obj1 = 0 ;
33163 char * kwnames[] = {
33164 (char *) "self",(char *) "action", NULL
33165 };
33166
33167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33169 if (!SWIG_IsOK(res1)) {
33170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33171 }
33172 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33173 ecode2 = SWIG_AsVal_int(obj1, &val2);
33174 if (!SWIG_IsOK(ecode2)) {
33175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33176 }
33177 arg2 = static_cast< wxDragResult >(val2);
33178 {
33179 PyThreadState* __tstate = wxPyBeginAllowThreads();
33180 (arg1)->SetDefaultAction(arg2);
33181 wxPyEndAllowThreads(__tstate);
33182 if (PyErr_Occurred()) SWIG_fail;
33183 }
33184 resultobj = SWIG_Py_Void();
33185 return resultobj;
33186 fail:
33187 return NULL;
33188 }
33189
33190
33191 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33192 PyObject *resultobj = 0;
33193 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33194 wxDragResult result;
33195 void *argp1 = 0 ;
33196 int res1 = 0 ;
33197 PyObject *swig_obj[1] ;
33198
33199 if (!args) SWIG_fail;
33200 swig_obj[0] = args;
33201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33202 if (!SWIG_IsOK(res1)) {
33203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33204 }
33205 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33206 {
33207 PyThreadState* __tstate = wxPyBeginAllowThreads();
33208 result = (wxDragResult)(arg1)->GetDefaultAction();
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 resultobj = SWIG_From_int(static_cast< int >(result));
33213 return resultobj;
33214 fail:
33215 return NULL;
33216 }
33217
33218
33219 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33220 PyObject *obj;
33221 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33222 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33223 return SWIG_Py_Void();
33224 }
33225
33226 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33227 return SWIG_Python_InitShadowInstance(args);
33228 }
33229
33230 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33231 PyObject *resultobj = 0;
33232 wxPyTextDropTarget *result = 0 ;
33233
33234 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33235 {
33236 PyThreadState* __tstate = wxPyBeginAllowThreads();
33237 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33238 wxPyEndAllowThreads(__tstate);
33239 if (PyErr_Occurred()) SWIG_fail;
33240 }
33241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33242 return resultobj;
33243 fail:
33244 return NULL;
33245 }
33246
33247
33248 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33249 PyObject *resultobj = 0;
33250 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33251 PyObject *arg2 = (PyObject *) 0 ;
33252 PyObject *arg3 = (PyObject *) 0 ;
33253 void *argp1 = 0 ;
33254 int res1 = 0 ;
33255 PyObject * obj0 = 0 ;
33256 PyObject * obj1 = 0 ;
33257 PyObject * obj2 = 0 ;
33258 char * kwnames[] = {
33259 (char *) "self",(char *) "self",(char *) "_class", NULL
33260 };
33261
33262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33264 if (!SWIG_IsOK(res1)) {
33265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33266 }
33267 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33268 arg2 = obj1;
33269 arg3 = obj2;
33270 {
33271 PyThreadState* __tstate = wxPyBeginAllowThreads();
33272 (arg1)->_setCallbackInfo(arg2,arg3);
33273 wxPyEndAllowThreads(__tstate);
33274 if (PyErr_Occurred()) SWIG_fail;
33275 }
33276 resultobj = SWIG_Py_Void();
33277 return resultobj;
33278 fail:
33279 return NULL;
33280 }
33281
33282
33283 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33284 PyObject *resultobj = 0;
33285 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33286 int arg2 ;
33287 int arg3 ;
33288 wxString *arg4 = 0 ;
33289 bool result;
33290 void *argp1 = 0 ;
33291 int res1 = 0 ;
33292 int val2 ;
33293 int ecode2 = 0 ;
33294 int val3 ;
33295 int ecode3 = 0 ;
33296 bool temp4 = false ;
33297 PyObject * obj0 = 0 ;
33298 PyObject * obj1 = 0 ;
33299 PyObject * obj2 = 0 ;
33300 PyObject * obj3 = 0 ;
33301 char * kwnames[] = {
33302 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33303 };
33304
33305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33307 if (!SWIG_IsOK(res1)) {
33308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33309 }
33310 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33311 ecode2 = SWIG_AsVal_int(obj1, &val2);
33312 if (!SWIG_IsOK(ecode2)) {
33313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33314 }
33315 arg2 = static_cast< int >(val2);
33316 ecode3 = SWIG_AsVal_int(obj2, &val3);
33317 if (!SWIG_IsOK(ecode3)) {
33318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33319 }
33320 arg3 = static_cast< int >(val3);
33321 {
33322 arg4 = wxString_in_helper(obj3);
33323 if (arg4 == NULL) SWIG_fail;
33324 temp4 = true;
33325 }
33326 {
33327 PyThreadState* __tstate = wxPyBeginAllowThreads();
33328 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33329 wxPyEndAllowThreads(__tstate);
33330 if (PyErr_Occurred()) SWIG_fail;
33331 }
33332 {
33333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33334 }
33335 {
33336 if (temp4)
33337 delete arg4;
33338 }
33339 return resultobj;
33340 fail:
33341 {
33342 if (temp4)
33343 delete arg4;
33344 }
33345 return NULL;
33346 }
33347
33348
33349 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33350 PyObject *resultobj = 0;
33351 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33352 int arg2 ;
33353 int arg3 ;
33354 wxDragResult arg4 ;
33355 wxDragResult result;
33356 void *argp1 = 0 ;
33357 int res1 = 0 ;
33358 int val2 ;
33359 int ecode2 = 0 ;
33360 int val3 ;
33361 int ecode3 = 0 ;
33362 int val4 ;
33363 int ecode4 = 0 ;
33364 PyObject * obj0 = 0 ;
33365 PyObject * obj1 = 0 ;
33366 PyObject * obj2 = 0 ;
33367 PyObject * obj3 = 0 ;
33368 char * kwnames[] = {
33369 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33370 };
33371
33372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33374 if (!SWIG_IsOK(res1)) {
33375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33376 }
33377 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33378 ecode2 = SWIG_AsVal_int(obj1, &val2);
33379 if (!SWIG_IsOK(ecode2)) {
33380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33381 }
33382 arg2 = static_cast< int >(val2);
33383 ecode3 = SWIG_AsVal_int(obj2, &val3);
33384 if (!SWIG_IsOK(ecode3)) {
33385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33386 }
33387 arg3 = static_cast< int >(val3);
33388 ecode4 = SWIG_AsVal_int(obj3, &val4);
33389 if (!SWIG_IsOK(ecode4)) {
33390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33391 }
33392 arg4 = static_cast< wxDragResult >(val4);
33393 {
33394 PyThreadState* __tstate = wxPyBeginAllowThreads();
33395 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33396 wxPyEndAllowThreads(__tstate);
33397 if (PyErr_Occurred()) SWIG_fail;
33398 }
33399 resultobj = SWIG_From_int(static_cast< int >(result));
33400 return resultobj;
33401 fail:
33402 return NULL;
33403 }
33404
33405
33406 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33407 PyObject *resultobj = 0;
33408 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33409 int arg2 ;
33410 int arg3 ;
33411 wxDragResult arg4 ;
33412 wxDragResult result;
33413 void *argp1 = 0 ;
33414 int res1 = 0 ;
33415 int val2 ;
33416 int ecode2 = 0 ;
33417 int val3 ;
33418 int ecode3 = 0 ;
33419 int val4 ;
33420 int ecode4 = 0 ;
33421 PyObject * obj0 = 0 ;
33422 PyObject * obj1 = 0 ;
33423 PyObject * obj2 = 0 ;
33424 PyObject * obj3 = 0 ;
33425 char * kwnames[] = {
33426 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33427 };
33428
33429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33431 if (!SWIG_IsOK(res1)) {
33432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33433 }
33434 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33435 ecode2 = SWIG_AsVal_int(obj1, &val2);
33436 if (!SWIG_IsOK(ecode2)) {
33437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33438 }
33439 arg2 = static_cast< int >(val2);
33440 ecode3 = SWIG_AsVal_int(obj2, &val3);
33441 if (!SWIG_IsOK(ecode3)) {
33442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33443 }
33444 arg3 = static_cast< int >(val3);
33445 ecode4 = SWIG_AsVal_int(obj3, &val4);
33446 if (!SWIG_IsOK(ecode4)) {
33447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33448 }
33449 arg4 = static_cast< wxDragResult >(val4);
33450 {
33451 PyThreadState* __tstate = wxPyBeginAllowThreads();
33452 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33453 wxPyEndAllowThreads(__tstate);
33454 if (PyErr_Occurred()) SWIG_fail;
33455 }
33456 resultobj = SWIG_From_int(static_cast< int >(result));
33457 return resultobj;
33458 fail:
33459 return NULL;
33460 }
33461
33462
33463 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33464 PyObject *resultobj = 0;
33465 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33466 void *argp1 = 0 ;
33467 int res1 = 0 ;
33468 PyObject *swig_obj[1] ;
33469
33470 if (!args) SWIG_fail;
33471 swig_obj[0] = args;
33472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33473 if (!SWIG_IsOK(res1)) {
33474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33475 }
33476 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33477 {
33478 PyThreadState* __tstate = wxPyBeginAllowThreads();
33479 (arg1)->OnLeave();
33480 wxPyEndAllowThreads(__tstate);
33481 if (PyErr_Occurred()) SWIG_fail;
33482 }
33483 resultobj = SWIG_Py_Void();
33484 return resultobj;
33485 fail:
33486 return NULL;
33487 }
33488
33489
33490 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33491 PyObject *resultobj = 0;
33492 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33493 int arg2 ;
33494 int arg3 ;
33495 bool result;
33496 void *argp1 = 0 ;
33497 int res1 = 0 ;
33498 int val2 ;
33499 int ecode2 = 0 ;
33500 int val3 ;
33501 int ecode3 = 0 ;
33502 PyObject * obj0 = 0 ;
33503 PyObject * obj1 = 0 ;
33504 PyObject * obj2 = 0 ;
33505 char * kwnames[] = {
33506 (char *) "self",(char *) "x",(char *) "y", NULL
33507 };
33508
33509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33511 if (!SWIG_IsOK(res1)) {
33512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33513 }
33514 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33515 ecode2 = SWIG_AsVal_int(obj1, &val2);
33516 if (!SWIG_IsOK(ecode2)) {
33517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33518 }
33519 arg2 = static_cast< int >(val2);
33520 ecode3 = SWIG_AsVal_int(obj2, &val3);
33521 if (!SWIG_IsOK(ecode3)) {
33522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33523 }
33524 arg3 = static_cast< int >(val3);
33525 {
33526 PyThreadState* __tstate = wxPyBeginAllowThreads();
33527 result = (bool)(arg1)->OnDrop(arg2,arg3);
33528 wxPyEndAllowThreads(__tstate);
33529 if (PyErr_Occurred()) SWIG_fail;
33530 }
33531 {
33532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33533 }
33534 return resultobj;
33535 fail:
33536 return NULL;
33537 }
33538
33539
33540 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33541 PyObject *resultobj = 0;
33542 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33543 int arg2 ;
33544 int arg3 ;
33545 wxDragResult arg4 ;
33546 wxDragResult result;
33547 void *argp1 = 0 ;
33548 int res1 = 0 ;
33549 int val2 ;
33550 int ecode2 = 0 ;
33551 int val3 ;
33552 int ecode3 = 0 ;
33553 int val4 ;
33554 int ecode4 = 0 ;
33555 PyObject * obj0 = 0 ;
33556 PyObject * obj1 = 0 ;
33557 PyObject * obj2 = 0 ;
33558 PyObject * obj3 = 0 ;
33559 char * kwnames[] = {
33560 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33561 };
33562
33563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33565 if (!SWIG_IsOK(res1)) {
33566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33567 }
33568 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33569 ecode2 = SWIG_AsVal_int(obj1, &val2);
33570 if (!SWIG_IsOK(ecode2)) {
33571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33572 }
33573 arg2 = static_cast< int >(val2);
33574 ecode3 = SWIG_AsVal_int(obj2, &val3);
33575 if (!SWIG_IsOK(ecode3)) {
33576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33577 }
33578 arg3 = static_cast< int >(val3);
33579 ecode4 = SWIG_AsVal_int(obj3, &val4);
33580 if (!SWIG_IsOK(ecode4)) {
33581 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33582 }
33583 arg4 = static_cast< wxDragResult >(val4);
33584 {
33585 PyThreadState* __tstate = wxPyBeginAllowThreads();
33586 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33587 wxPyEndAllowThreads(__tstate);
33588 if (PyErr_Occurred()) SWIG_fail;
33589 }
33590 resultobj = SWIG_From_int(static_cast< int >(result));
33591 return resultobj;
33592 fail:
33593 return NULL;
33594 }
33595
33596
33597 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33598 PyObject *obj;
33599 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33600 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33601 return SWIG_Py_Void();
33602 }
33603
33604 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33605 return SWIG_Python_InitShadowInstance(args);
33606 }
33607
33608 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33609 PyObject *resultobj = 0;
33610 wxPyFileDropTarget *result = 0 ;
33611
33612 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33613 {
33614 PyThreadState* __tstate = wxPyBeginAllowThreads();
33615 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33616 wxPyEndAllowThreads(__tstate);
33617 if (PyErr_Occurred()) SWIG_fail;
33618 }
33619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33620 return resultobj;
33621 fail:
33622 return NULL;
33623 }
33624
33625
33626 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33627 PyObject *resultobj = 0;
33628 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33629 PyObject *arg2 = (PyObject *) 0 ;
33630 PyObject *arg3 = (PyObject *) 0 ;
33631 void *argp1 = 0 ;
33632 int res1 = 0 ;
33633 PyObject * obj0 = 0 ;
33634 PyObject * obj1 = 0 ;
33635 PyObject * obj2 = 0 ;
33636 char * kwnames[] = {
33637 (char *) "self",(char *) "self",(char *) "_class", NULL
33638 };
33639
33640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33642 if (!SWIG_IsOK(res1)) {
33643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33644 }
33645 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33646 arg2 = obj1;
33647 arg3 = obj2;
33648 {
33649 PyThreadState* __tstate = wxPyBeginAllowThreads();
33650 (arg1)->_setCallbackInfo(arg2,arg3);
33651 wxPyEndAllowThreads(__tstate);
33652 if (PyErr_Occurred()) SWIG_fail;
33653 }
33654 resultobj = SWIG_Py_Void();
33655 return resultobj;
33656 fail:
33657 return NULL;
33658 }
33659
33660
33661 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33662 PyObject *resultobj = 0;
33663 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33664 int arg2 ;
33665 int arg3 ;
33666 wxArrayString *arg4 = 0 ;
33667 bool result;
33668 void *argp1 = 0 ;
33669 int res1 = 0 ;
33670 int val2 ;
33671 int ecode2 = 0 ;
33672 int val3 ;
33673 int ecode3 = 0 ;
33674 bool temp4 = false ;
33675 PyObject * obj0 = 0 ;
33676 PyObject * obj1 = 0 ;
33677 PyObject * obj2 = 0 ;
33678 PyObject * obj3 = 0 ;
33679 char * kwnames[] = {
33680 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33681 };
33682
33683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33685 if (!SWIG_IsOK(res1)) {
33686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33687 }
33688 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33689 ecode2 = SWIG_AsVal_int(obj1, &val2);
33690 if (!SWIG_IsOK(ecode2)) {
33691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33692 }
33693 arg2 = static_cast< int >(val2);
33694 ecode3 = SWIG_AsVal_int(obj2, &val3);
33695 if (!SWIG_IsOK(ecode3)) {
33696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33697 }
33698 arg3 = static_cast< int >(val3);
33699 {
33700 if (! PySequence_Check(obj3)) {
33701 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33702 SWIG_fail;
33703 }
33704 arg4 = new wxArrayString;
33705 temp4 = true;
33706 int i, len=PySequence_Length(obj3);
33707 for (i=0; i<len; i++) {
33708 PyObject* item = PySequence_GetItem(obj3, i);
33709 wxString* s = wxString_in_helper(item);
33710 if (PyErr_Occurred()) SWIG_fail;
33711 arg4->Add(*s);
33712 delete s;
33713 Py_DECREF(item);
33714 }
33715 }
33716 {
33717 PyThreadState* __tstate = wxPyBeginAllowThreads();
33718 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33719 wxPyEndAllowThreads(__tstate);
33720 if (PyErr_Occurred()) SWIG_fail;
33721 }
33722 {
33723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33724 }
33725 {
33726 if (temp4) delete arg4;
33727 }
33728 return resultobj;
33729 fail:
33730 {
33731 if (temp4) delete arg4;
33732 }
33733 return NULL;
33734 }
33735
33736
33737 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33738 PyObject *resultobj = 0;
33739 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33740 int arg2 ;
33741 int arg3 ;
33742 wxDragResult arg4 ;
33743 wxDragResult result;
33744 void *argp1 = 0 ;
33745 int res1 = 0 ;
33746 int val2 ;
33747 int ecode2 = 0 ;
33748 int val3 ;
33749 int ecode3 = 0 ;
33750 int val4 ;
33751 int ecode4 = 0 ;
33752 PyObject * obj0 = 0 ;
33753 PyObject * obj1 = 0 ;
33754 PyObject * obj2 = 0 ;
33755 PyObject * obj3 = 0 ;
33756 char * kwnames[] = {
33757 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33758 };
33759
33760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33762 if (!SWIG_IsOK(res1)) {
33763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33764 }
33765 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33766 ecode2 = SWIG_AsVal_int(obj1, &val2);
33767 if (!SWIG_IsOK(ecode2)) {
33768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33769 }
33770 arg2 = static_cast< int >(val2);
33771 ecode3 = SWIG_AsVal_int(obj2, &val3);
33772 if (!SWIG_IsOK(ecode3)) {
33773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33774 }
33775 arg3 = static_cast< int >(val3);
33776 ecode4 = SWIG_AsVal_int(obj3, &val4);
33777 if (!SWIG_IsOK(ecode4)) {
33778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33779 }
33780 arg4 = static_cast< wxDragResult >(val4);
33781 {
33782 PyThreadState* __tstate = wxPyBeginAllowThreads();
33783 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33784 wxPyEndAllowThreads(__tstate);
33785 if (PyErr_Occurred()) SWIG_fail;
33786 }
33787 resultobj = SWIG_From_int(static_cast< int >(result));
33788 return resultobj;
33789 fail:
33790 return NULL;
33791 }
33792
33793
33794 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33795 PyObject *resultobj = 0;
33796 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33797 int arg2 ;
33798 int arg3 ;
33799 wxDragResult arg4 ;
33800 wxDragResult result;
33801 void *argp1 = 0 ;
33802 int res1 = 0 ;
33803 int val2 ;
33804 int ecode2 = 0 ;
33805 int val3 ;
33806 int ecode3 = 0 ;
33807 int val4 ;
33808 int ecode4 = 0 ;
33809 PyObject * obj0 = 0 ;
33810 PyObject * obj1 = 0 ;
33811 PyObject * obj2 = 0 ;
33812 PyObject * obj3 = 0 ;
33813 char * kwnames[] = {
33814 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33815 };
33816
33817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33819 if (!SWIG_IsOK(res1)) {
33820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33821 }
33822 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33823 ecode2 = SWIG_AsVal_int(obj1, &val2);
33824 if (!SWIG_IsOK(ecode2)) {
33825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33826 }
33827 arg2 = static_cast< int >(val2);
33828 ecode3 = SWIG_AsVal_int(obj2, &val3);
33829 if (!SWIG_IsOK(ecode3)) {
33830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33831 }
33832 arg3 = static_cast< int >(val3);
33833 ecode4 = SWIG_AsVal_int(obj3, &val4);
33834 if (!SWIG_IsOK(ecode4)) {
33835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33836 }
33837 arg4 = static_cast< wxDragResult >(val4);
33838 {
33839 PyThreadState* __tstate = wxPyBeginAllowThreads();
33840 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33841 wxPyEndAllowThreads(__tstate);
33842 if (PyErr_Occurred()) SWIG_fail;
33843 }
33844 resultobj = SWIG_From_int(static_cast< int >(result));
33845 return resultobj;
33846 fail:
33847 return NULL;
33848 }
33849
33850
33851 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33852 PyObject *resultobj = 0;
33853 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33854 void *argp1 = 0 ;
33855 int res1 = 0 ;
33856 PyObject *swig_obj[1] ;
33857
33858 if (!args) SWIG_fail;
33859 swig_obj[0] = args;
33860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33861 if (!SWIG_IsOK(res1)) {
33862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33863 }
33864 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33865 {
33866 PyThreadState* __tstate = wxPyBeginAllowThreads();
33867 (arg1)->OnLeave();
33868 wxPyEndAllowThreads(__tstate);
33869 if (PyErr_Occurred()) SWIG_fail;
33870 }
33871 resultobj = SWIG_Py_Void();
33872 return resultobj;
33873 fail:
33874 return NULL;
33875 }
33876
33877
33878 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33879 PyObject *resultobj = 0;
33880 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33881 int arg2 ;
33882 int arg3 ;
33883 bool result;
33884 void *argp1 = 0 ;
33885 int res1 = 0 ;
33886 int val2 ;
33887 int ecode2 = 0 ;
33888 int val3 ;
33889 int ecode3 = 0 ;
33890 PyObject * obj0 = 0 ;
33891 PyObject * obj1 = 0 ;
33892 PyObject * obj2 = 0 ;
33893 char * kwnames[] = {
33894 (char *) "self",(char *) "x",(char *) "y", NULL
33895 };
33896
33897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33899 if (!SWIG_IsOK(res1)) {
33900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33901 }
33902 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33903 ecode2 = SWIG_AsVal_int(obj1, &val2);
33904 if (!SWIG_IsOK(ecode2)) {
33905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33906 }
33907 arg2 = static_cast< int >(val2);
33908 ecode3 = SWIG_AsVal_int(obj2, &val3);
33909 if (!SWIG_IsOK(ecode3)) {
33910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33911 }
33912 arg3 = static_cast< int >(val3);
33913 {
33914 PyThreadState* __tstate = wxPyBeginAllowThreads();
33915 result = (bool)(arg1)->OnDrop(arg2,arg3);
33916 wxPyEndAllowThreads(__tstate);
33917 if (PyErr_Occurred()) SWIG_fail;
33918 }
33919 {
33920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33921 }
33922 return resultobj;
33923 fail:
33924 return NULL;
33925 }
33926
33927
33928 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33929 PyObject *resultobj = 0;
33930 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33931 int arg2 ;
33932 int arg3 ;
33933 wxDragResult arg4 ;
33934 wxDragResult result;
33935 void *argp1 = 0 ;
33936 int res1 = 0 ;
33937 int val2 ;
33938 int ecode2 = 0 ;
33939 int val3 ;
33940 int ecode3 = 0 ;
33941 int val4 ;
33942 int ecode4 = 0 ;
33943 PyObject * obj0 = 0 ;
33944 PyObject * obj1 = 0 ;
33945 PyObject * obj2 = 0 ;
33946 PyObject * obj3 = 0 ;
33947 char * kwnames[] = {
33948 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33949 };
33950
33951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33953 if (!SWIG_IsOK(res1)) {
33954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33955 }
33956 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33957 ecode2 = SWIG_AsVal_int(obj1, &val2);
33958 if (!SWIG_IsOK(ecode2)) {
33959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33960 }
33961 arg2 = static_cast< int >(val2);
33962 ecode3 = SWIG_AsVal_int(obj2, &val3);
33963 if (!SWIG_IsOK(ecode3)) {
33964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33965 }
33966 arg3 = static_cast< int >(val3);
33967 ecode4 = SWIG_AsVal_int(obj3, &val4);
33968 if (!SWIG_IsOK(ecode4)) {
33969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33970 }
33971 arg4 = static_cast< wxDragResult >(val4);
33972 {
33973 PyThreadState* __tstate = wxPyBeginAllowThreads();
33974 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33975 wxPyEndAllowThreads(__tstate);
33976 if (PyErr_Occurred()) SWIG_fail;
33977 }
33978 resultobj = SWIG_From_int(static_cast< int >(result));
33979 return resultobj;
33980 fail:
33981 return NULL;
33982 }
33983
33984
33985 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33986 PyObject *obj;
33987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33989 return SWIG_Py_Void();
33990 }
33991
33992 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33993 return SWIG_Python_InitShadowInstance(args);
33994 }
33995
33996 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33997 PyObject *resultobj = 0;
33998 wxClipboard *result = 0 ;
33999
34000 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
34001 {
34002 PyThreadState* __tstate = wxPyBeginAllowThreads();
34003 result = (wxClipboard *)new wxClipboard();
34004 wxPyEndAllowThreads(__tstate);
34005 if (PyErr_Occurred()) SWIG_fail;
34006 }
34007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
34008 return resultobj;
34009 fail:
34010 return NULL;
34011 }
34012
34013
34014 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34015 PyObject *resultobj = 0;
34016 wxClipboard *arg1 = (wxClipboard *) 0 ;
34017 void *argp1 = 0 ;
34018 int res1 = 0 ;
34019 PyObject *swig_obj[1] ;
34020
34021 if (!args) SWIG_fail;
34022 swig_obj[0] = args;
34023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34024 if (!SWIG_IsOK(res1)) {
34025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34026 }
34027 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34028 {
34029 PyThreadState* __tstate = wxPyBeginAllowThreads();
34030 delete arg1;
34031
34032 wxPyEndAllowThreads(__tstate);
34033 if (PyErr_Occurred()) SWIG_fail;
34034 }
34035 resultobj = SWIG_Py_Void();
34036 return resultobj;
34037 fail:
34038 return NULL;
34039 }
34040
34041
34042 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34043 PyObject *resultobj = 0;
34044 wxClipboard *arg1 = (wxClipboard *) 0 ;
34045 bool result;
34046 void *argp1 = 0 ;
34047 int res1 = 0 ;
34048 PyObject *swig_obj[1] ;
34049
34050 if (!args) SWIG_fail;
34051 swig_obj[0] = args;
34052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34053 if (!SWIG_IsOK(res1)) {
34054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34055 }
34056 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (bool)(arg1)->Open();
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 {
34064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34065 }
34066 return resultobj;
34067 fail:
34068 return NULL;
34069 }
34070
34071
34072 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34073 PyObject *resultobj = 0;
34074 wxClipboard *arg1 = (wxClipboard *) 0 ;
34075 void *argp1 = 0 ;
34076 int res1 = 0 ;
34077 PyObject *swig_obj[1] ;
34078
34079 if (!args) SWIG_fail;
34080 swig_obj[0] = args;
34081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34082 if (!SWIG_IsOK(res1)) {
34083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34084 }
34085 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34086 {
34087 PyThreadState* __tstate = wxPyBeginAllowThreads();
34088 (arg1)->Close();
34089 wxPyEndAllowThreads(__tstate);
34090 if (PyErr_Occurred()) SWIG_fail;
34091 }
34092 resultobj = SWIG_Py_Void();
34093 return resultobj;
34094 fail:
34095 return NULL;
34096 }
34097
34098
34099 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34100 PyObject *resultobj = 0;
34101 wxClipboard *arg1 = (wxClipboard *) 0 ;
34102 bool result;
34103 void *argp1 = 0 ;
34104 int res1 = 0 ;
34105 PyObject *swig_obj[1] ;
34106
34107 if (!args) SWIG_fail;
34108 swig_obj[0] = args;
34109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34110 if (!SWIG_IsOK(res1)) {
34111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34112 }
34113 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34114 {
34115 PyThreadState* __tstate = wxPyBeginAllowThreads();
34116 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34117 wxPyEndAllowThreads(__tstate);
34118 if (PyErr_Occurred()) SWIG_fail;
34119 }
34120 {
34121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34122 }
34123 return resultobj;
34124 fail:
34125 return NULL;
34126 }
34127
34128
34129 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34130 PyObject *resultobj = 0;
34131 wxClipboard *arg1 = (wxClipboard *) 0 ;
34132 wxDataObject *arg2 = (wxDataObject *) 0 ;
34133 bool result;
34134 void *argp1 = 0 ;
34135 int res1 = 0 ;
34136 int res2 = 0 ;
34137 PyObject * obj0 = 0 ;
34138 PyObject * obj1 = 0 ;
34139 char * kwnames[] = {
34140 (char *) "self",(char *) "data", NULL
34141 };
34142
34143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34145 if (!SWIG_IsOK(res1)) {
34146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34147 }
34148 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34149 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34150 if (!SWIG_IsOK(res2)) {
34151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34152 }
34153 {
34154 PyThreadState* __tstate = wxPyBeginAllowThreads();
34155 result = (bool)(arg1)->AddData(arg2);
34156 wxPyEndAllowThreads(__tstate);
34157 if (PyErr_Occurred()) SWIG_fail;
34158 }
34159 {
34160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34161 }
34162 return resultobj;
34163 fail:
34164 return NULL;
34165 }
34166
34167
34168 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34169 PyObject *resultobj = 0;
34170 wxClipboard *arg1 = (wxClipboard *) 0 ;
34171 wxDataObject *arg2 = (wxDataObject *) 0 ;
34172 bool result;
34173 void *argp1 = 0 ;
34174 int res1 = 0 ;
34175 int res2 = 0 ;
34176 PyObject * obj0 = 0 ;
34177 PyObject * obj1 = 0 ;
34178 char * kwnames[] = {
34179 (char *) "self",(char *) "data", NULL
34180 };
34181
34182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34184 if (!SWIG_IsOK(res1)) {
34185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34186 }
34187 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34188 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34189 if (!SWIG_IsOK(res2)) {
34190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34191 }
34192 {
34193 PyThreadState* __tstate = wxPyBeginAllowThreads();
34194 result = (bool)(arg1)->SetData(arg2);
34195 wxPyEndAllowThreads(__tstate);
34196 if (PyErr_Occurred()) SWIG_fail;
34197 }
34198 {
34199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34200 }
34201 return resultobj;
34202 fail:
34203 return NULL;
34204 }
34205
34206
34207 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34208 PyObject *resultobj = 0;
34209 wxClipboard *arg1 = (wxClipboard *) 0 ;
34210 wxDataFormat *arg2 = 0 ;
34211 bool result;
34212 void *argp1 = 0 ;
34213 int res1 = 0 ;
34214 void *argp2 = 0 ;
34215 int res2 = 0 ;
34216 PyObject * obj0 = 0 ;
34217 PyObject * obj1 = 0 ;
34218 char * kwnames[] = {
34219 (char *) "self",(char *) "format", NULL
34220 };
34221
34222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34224 if (!SWIG_IsOK(res1)) {
34225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34226 }
34227 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34228 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34229 if (!SWIG_IsOK(res2)) {
34230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34231 }
34232 if (!argp2) {
34233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34234 }
34235 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34236 {
34237 PyThreadState* __tstate = wxPyBeginAllowThreads();
34238 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34239 wxPyEndAllowThreads(__tstate);
34240 if (PyErr_Occurred()) SWIG_fail;
34241 }
34242 {
34243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34244 }
34245 return resultobj;
34246 fail:
34247 return NULL;
34248 }
34249
34250
34251 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34252 PyObject *resultobj = 0;
34253 wxClipboard *arg1 = (wxClipboard *) 0 ;
34254 wxDataObject *arg2 = 0 ;
34255 bool result;
34256 void *argp1 = 0 ;
34257 int res1 = 0 ;
34258 void *argp2 = 0 ;
34259 int res2 = 0 ;
34260 PyObject * obj0 = 0 ;
34261 PyObject * obj1 = 0 ;
34262 char * kwnames[] = {
34263 (char *) "self",(char *) "data", NULL
34264 };
34265
34266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34268 if (!SWIG_IsOK(res1)) {
34269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34270 }
34271 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34272 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34273 if (!SWIG_IsOK(res2)) {
34274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34275 }
34276 if (!argp2) {
34277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34278 }
34279 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34280 {
34281 PyThreadState* __tstate = wxPyBeginAllowThreads();
34282 result = (bool)(arg1)->GetData(*arg2);
34283 wxPyEndAllowThreads(__tstate);
34284 if (PyErr_Occurred()) SWIG_fail;
34285 }
34286 {
34287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34288 }
34289 return resultobj;
34290 fail:
34291 return NULL;
34292 }
34293
34294
34295 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34296 PyObject *resultobj = 0;
34297 wxClipboard *arg1 = (wxClipboard *) 0 ;
34298 void *argp1 = 0 ;
34299 int res1 = 0 ;
34300 PyObject *swig_obj[1] ;
34301
34302 if (!args) SWIG_fail;
34303 swig_obj[0] = args;
34304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34305 if (!SWIG_IsOK(res1)) {
34306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34307 }
34308 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34309 {
34310 PyThreadState* __tstate = wxPyBeginAllowThreads();
34311 (arg1)->Clear();
34312 wxPyEndAllowThreads(__tstate);
34313 if (PyErr_Occurred()) SWIG_fail;
34314 }
34315 resultobj = SWIG_Py_Void();
34316 return resultobj;
34317 fail:
34318 return NULL;
34319 }
34320
34321
34322 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34323 PyObject *resultobj = 0;
34324 wxClipboard *arg1 = (wxClipboard *) 0 ;
34325 bool result;
34326 void *argp1 = 0 ;
34327 int res1 = 0 ;
34328 PyObject *swig_obj[1] ;
34329
34330 if (!args) SWIG_fail;
34331 swig_obj[0] = args;
34332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34333 if (!SWIG_IsOK(res1)) {
34334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34335 }
34336 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34337 {
34338 PyThreadState* __tstate = wxPyBeginAllowThreads();
34339 result = (bool)(arg1)->Flush();
34340 wxPyEndAllowThreads(__tstate);
34341 if (PyErr_Occurred()) SWIG_fail;
34342 }
34343 {
34344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34345 }
34346 return resultobj;
34347 fail:
34348 return NULL;
34349 }
34350
34351
34352 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34353 PyObject *resultobj = 0;
34354 wxClipboard *arg1 = (wxClipboard *) 0 ;
34355 bool arg2 = (bool) true ;
34356 void *argp1 = 0 ;
34357 int res1 = 0 ;
34358 bool val2 ;
34359 int ecode2 = 0 ;
34360 PyObject * obj0 = 0 ;
34361 PyObject * obj1 = 0 ;
34362 char * kwnames[] = {
34363 (char *) "self",(char *) "primary", NULL
34364 };
34365
34366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34368 if (!SWIG_IsOK(res1)) {
34369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34370 }
34371 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34372 if (obj1) {
34373 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34374 if (!SWIG_IsOK(ecode2)) {
34375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34376 }
34377 arg2 = static_cast< bool >(val2);
34378 }
34379 {
34380 PyThreadState* __tstate = wxPyBeginAllowThreads();
34381 (arg1)->UsePrimarySelection(arg2);
34382 wxPyEndAllowThreads(__tstate);
34383 if (PyErr_Occurred()) SWIG_fail;
34384 }
34385 resultobj = SWIG_Py_Void();
34386 return resultobj;
34387 fail:
34388 return NULL;
34389 }
34390
34391
34392 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34393 PyObject *resultobj = 0;
34394 wxClipboard *result = 0 ;
34395
34396 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34397 {
34398 PyThreadState* __tstate = wxPyBeginAllowThreads();
34399 result = (wxClipboard *)wxClipboard::Get();
34400 wxPyEndAllowThreads(__tstate);
34401 if (PyErr_Occurred()) SWIG_fail;
34402 }
34403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34404 return resultobj;
34405 fail:
34406 return NULL;
34407 }
34408
34409
34410 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34411 PyObject *obj;
34412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34413 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34414 return SWIG_Py_Void();
34415 }
34416
34417 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34418 return SWIG_Python_InitShadowInstance(args);
34419 }
34420
34421 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34422 PyObject *resultobj = 0;
34423 wxClipboard *arg1 = (wxClipboard *) NULL ;
34424 wxClipboardLocker *result = 0 ;
34425 void *argp1 = 0 ;
34426 int res1 = 0 ;
34427 PyObject * obj0 = 0 ;
34428 char * kwnames[] = {
34429 (char *) "clipboard", NULL
34430 };
34431
34432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34433 if (obj0) {
34434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34435 if (!SWIG_IsOK(res1)) {
34436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34437 }
34438 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34439 }
34440 {
34441 PyThreadState* __tstate = wxPyBeginAllowThreads();
34442 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34443 wxPyEndAllowThreads(__tstate);
34444 if (PyErr_Occurred()) SWIG_fail;
34445 }
34446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34447 return resultobj;
34448 fail:
34449 return NULL;
34450 }
34451
34452
34453 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34454 PyObject *resultobj = 0;
34455 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34456 void *argp1 = 0 ;
34457 int res1 = 0 ;
34458 PyObject *swig_obj[1] ;
34459
34460 if (!args) SWIG_fail;
34461 swig_obj[0] = args;
34462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34463 if (!SWIG_IsOK(res1)) {
34464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34465 }
34466 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34467 {
34468 PyThreadState* __tstate = wxPyBeginAllowThreads();
34469 delete arg1;
34470
34471 wxPyEndAllowThreads(__tstate);
34472 if (PyErr_Occurred()) SWIG_fail;
34473 }
34474 resultobj = SWIG_Py_Void();
34475 return resultobj;
34476 fail:
34477 return NULL;
34478 }
34479
34480
34481 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34482 PyObject *resultobj = 0;
34483 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34484 bool result;
34485 void *argp1 = 0 ;
34486 int res1 = 0 ;
34487 PyObject *swig_obj[1] ;
34488
34489 if (!args) SWIG_fail;
34490 swig_obj[0] = args;
34491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34492 if (!SWIG_IsOK(res1)) {
34493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34494 }
34495 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34496 {
34497 PyThreadState* __tstate = wxPyBeginAllowThreads();
34498 result = (bool)wxClipboardLocker___nonzero__(arg1);
34499 wxPyEndAllowThreads(__tstate);
34500 if (PyErr_Occurred()) SWIG_fail;
34501 }
34502 {
34503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34504 }
34505 return resultobj;
34506 fail:
34507 return NULL;
34508 }
34509
34510
34511 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34512 PyObject *obj;
34513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34514 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34515 return SWIG_Py_Void();
34516 }
34517
34518 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34519 return SWIG_Python_InitShadowInstance(args);
34520 }
34521
34522 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34523 PyObject *resultobj = 0;
34524 int arg1 = (int) 0 ;
34525 int arg2 = (int) 0 ;
34526 int arg3 = (int) 0 ;
34527 int arg4 = (int) 0 ;
34528 wxVideoMode *result = 0 ;
34529 int val1 ;
34530 int ecode1 = 0 ;
34531 int val2 ;
34532 int ecode2 = 0 ;
34533 int val3 ;
34534 int ecode3 = 0 ;
34535 int val4 ;
34536 int ecode4 = 0 ;
34537 PyObject * obj0 = 0 ;
34538 PyObject * obj1 = 0 ;
34539 PyObject * obj2 = 0 ;
34540 PyObject * obj3 = 0 ;
34541 char * kwnames[] = {
34542 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34543 };
34544
34545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34546 if (obj0) {
34547 ecode1 = SWIG_AsVal_int(obj0, &val1);
34548 if (!SWIG_IsOK(ecode1)) {
34549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34550 }
34551 arg1 = static_cast< int >(val1);
34552 }
34553 if (obj1) {
34554 ecode2 = SWIG_AsVal_int(obj1, &val2);
34555 if (!SWIG_IsOK(ecode2)) {
34556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34557 }
34558 arg2 = static_cast< int >(val2);
34559 }
34560 if (obj2) {
34561 ecode3 = SWIG_AsVal_int(obj2, &val3);
34562 if (!SWIG_IsOK(ecode3)) {
34563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34564 }
34565 arg3 = static_cast< int >(val3);
34566 }
34567 if (obj3) {
34568 ecode4 = SWIG_AsVal_int(obj3, &val4);
34569 if (!SWIG_IsOK(ecode4)) {
34570 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34571 }
34572 arg4 = static_cast< int >(val4);
34573 }
34574 {
34575 PyThreadState* __tstate = wxPyBeginAllowThreads();
34576 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34577 wxPyEndAllowThreads(__tstate);
34578 if (PyErr_Occurred()) SWIG_fail;
34579 }
34580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34581 return resultobj;
34582 fail:
34583 return NULL;
34584 }
34585
34586
34587 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34588 PyObject *resultobj = 0;
34589 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34590 void *argp1 = 0 ;
34591 int res1 = 0 ;
34592 PyObject *swig_obj[1] ;
34593
34594 if (!args) SWIG_fail;
34595 swig_obj[0] = args;
34596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34597 if (!SWIG_IsOK(res1)) {
34598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34599 }
34600 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34601 {
34602 PyThreadState* __tstate = wxPyBeginAllowThreads();
34603 delete arg1;
34604
34605 wxPyEndAllowThreads(__tstate);
34606 if (PyErr_Occurred()) SWIG_fail;
34607 }
34608 resultobj = SWIG_Py_Void();
34609 return resultobj;
34610 fail:
34611 return NULL;
34612 }
34613
34614
34615 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34616 PyObject *resultobj = 0;
34617 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34618 wxVideoMode *arg2 = 0 ;
34619 bool result;
34620 void *argp1 = 0 ;
34621 int res1 = 0 ;
34622 void *argp2 = 0 ;
34623 int res2 = 0 ;
34624 PyObject * obj0 = 0 ;
34625 PyObject * obj1 = 0 ;
34626 char * kwnames[] = {
34627 (char *) "self",(char *) "other", NULL
34628 };
34629
34630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34632 if (!SWIG_IsOK(res1)) {
34633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34634 }
34635 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34636 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34637 if (!SWIG_IsOK(res2)) {
34638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34639 }
34640 if (!argp2) {
34641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34642 }
34643 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34644 {
34645 PyThreadState* __tstate = wxPyBeginAllowThreads();
34646 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34647 wxPyEndAllowThreads(__tstate);
34648 if (PyErr_Occurred()) SWIG_fail;
34649 }
34650 {
34651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34652 }
34653 return resultobj;
34654 fail:
34655 return NULL;
34656 }
34657
34658
34659 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34660 PyObject *resultobj = 0;
34661 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34662 int result;
34663 void *argp1 = 0 ;
34664 int res1 = 0 ;
34665 PyObject *swig_obj[1] ;
34666
34667 if (!args) SWIG_fail;
34668 swig_obj[0] = args;
34669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34670 if (!SWIG_IsOK(res1)) {
34671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34672 }
34673 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34674 {
34675 PyThreadState* __tstate = wxPyBeginAllowThreads();
34676 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34677 wxPyEndAllowThreads(__tstate);
34678 if (PyErr_Occurred()) SWIG_fail;
34679 }
34680 resultobj = SWIG_From_int(static_cast< int >(result));
34681 return resultobj;
34682 fail:
34683 return NULL;
34684 }
34685
34686
34687 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34688 PyObject *resultobj = 0;
34689 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34690 int result;
34691 void *argp1 = 0 ;
34692 int res1 = 0 ;
34693 PyObject *swig_obj[1] ;
34694
34695 if (!args) SWIG_fail;
34696 swig_obj[0] = args;
34697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34698 if (!SWIG_IsOK(res1)) {
34699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34700 }
34701 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34702 {
34703 PyThreadState* __tstate = wxPyBeginAllowThreads();
34704 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34705 wxPyEndAllowThreads(__tstate);
34706 if (PyErr_Occurred()) SWIG_fail;
34707 }
34708 resultobj = SWIG_From_int(static_cast< int >(result));
34709 return resultobj;
34710 fail:
34711 return NULL;
34712 }
34713
34714
34715 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34716 PyObject *resultobj = 0;
34717 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34718 int result;
34719 void *argp1 = 0 ;
34720 int res1 = 0 ;
34721 PyObject *swig_obj[1] ;
34722
34723 if (!args) SWIG_fail;
34724 swig_obj[0] = args;
34725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34728 }
34729 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34730 {
34731 PyThreadState* __tstate = wxPyBeginAllowThreads();
34732 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34733 wxPyEndAllowThreads(__tstate);
34734 if (PyErr_Occurred()) SWIG_fail;
34735 }
34736 resultobj = SWIG_From_int(static_cast< int >(result));
34737 return resultobj;
34738 fail:
34739 return NULL;
34740 }
34741
34742
34743 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34744 PyObject *resultobj = 0;
34745 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34746 bool result;
34747 void *argp1 = 0 ;
34748 int res1 = 0 ;
34749 PyObject *swig_obj[1] ;
34750
34751 if (!args) SWIG_fail;
34752 swig_obj[0] = args;
34753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34754 if (!SWIG_IsOK(res1)) {
34755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34756 }
34757 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34758 {
34759 PyThreadState* __tstate = wxPyBeginAllowThreads();
34760 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34761 wxPyEndAllowThreads(__tstate);
34762 if (PyErr_Occurred()) SWIG_fail;
34763 }
34764 {
34765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34766 }
34767 return resultobj;
34768 fail:
34769 return NULL;
34770 }
34771
34772
34773 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34774 PyObject *resultobj = 0;
34775 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34776 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34777 bool result;
34778 void *argp1 = 0 ;
34779 int res1 = 0 ;
34780 void *argp2 = 0 ;
34781 int res2 = 0 ;
34782 PyObject * obj0 = 0 ;
34783 PyObject * obj1 = 0 ;
34784 char * kwnames[] = {
34785 (char *) "self",(char *) "other", NULL
34786 };
34787
34788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34790 if (!SWIG_IsOK(res1)) {
34791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34792 }
34793 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34794 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34795 if (!SWIG_IsOK(res2)) {
34796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34797 }
34798 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34799 {
34800 PyThreadState* __tstate = wxPyBeginAllowThreads();
34801 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34802 wxPyEndAllowThreads(__tstate);
34803 if (PyErr_Occurred()) SWIG_fail;
34804 }
34805 {
34806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34807 }
34808 return resultobj;
34809 fail:
34810 return NULL;
34811 }
34812
34813
34814 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34815 PyObject *resultobj = 0;
34816 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34817 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34818 bool result;
34819 void *argp1 = 0 ;
34820 int res1 = 0 ;
34821 void *argp2 = 0 ;
34822 int res2 = 0 ;
34823 PyObject * obj0 = 0 ;
34824 PyObject * obj1 = 0 ;
34825 char * kwnames[] = {
34826 (char *) "self",(char *) "other", NULL
34827 };
34828
34829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34831 if (!SWIG_IsOK(res1)) {
34832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34833 }
34834 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34835 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34836 if (!SWIG_IsOK(res2)) {
34837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34838 }
34839 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34840 {
34841 PyThreadState* __tstate = wxPyBeginAllowThreads();
34842 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34843 wxPyEndAllowThreads(__tstate);
34844 if (PyErr_Occurred()) SWIG_fail;
34845 }
34846 {
34847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34848 }
34849 return resultobj;
34850 fail:
34851 return NULL;
34852 }
34853
34854
34855 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34856 PyObject *resultobj = 0;
34857 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34858 int arg2 ;
34859 void *argp1 = 0 ;
34860 int res1 = 0 ;
34861 int val2 ;
34862 int ecode2 = 0 ;
34863 PyObject *swig_obj[2] ;
34864
34865 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34867 if (!SWIG_IsOK(res1)) {
34868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34869 }
34870 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34871 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34872 if (!SWIG_IsOK(ecode2)) {
34873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34874 }
34875 arg2 = static_cast< int >(val2);
34876 if (arg1) (arg1)->w = arg2;
34877
34878 resultobj = SWIG_Py_Void();
34879 return resultobj;
34880 fail:
34881 return NULL;
34882 }
34883
34884
34885 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34886 PyObject *resultobj = 0;
34887 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34888 int result;
34889 void *argp1 = 0 ;
34890 int res1 = 0 ;
34891 PyObject *swig_obj[1] ;
34892
34893 if (!args) SWIG_fail;
34894 swig_obj[0] = args;
34895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34896 if (!SWIG_IsOK(res1)) {
34897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34898 }
34899 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34900 result = (int) ((arg1)->w);
34901 resultobj = SWIG_From_int(static_cast< int >(result));
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34909 PyObject *resultobj = 0;
34910 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34911 int arg2 ;
34912 void *argp1 = 0 ;
34913 int res1 = 0 ;
34914 int val2 ;
34915 int ecode2 = 0 ;
34916 PyObject *swig_obj[2] ;
34917
34918 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34920 if (!SWIG_IsOK(res1)) {
34921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34922 }
34923 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34924 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34925 if (!SWIG_IsOK(ecode2)) {
34926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34927 }
34928 arg2 = static_cast< int >(val2);
34929 if (arg1) (arg1)->h = arg2;
34930
34931 resultobj = SWIG_Py_Void();
34932 return resultobj;
34933 fail:
34934 return NULL;
34935 }
34936
34937
34938 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34939 PyObject *resultobj = 0;
34940 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34941 int result;
34942 void *argp1 = 0 ;
34943 int res1 = 0 ;
34944 PyObject *swig_obj[1] ;
34945
34946 if (!args) SWIG_fail;
34947 swig_obj[0] = args;
34948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34949 if (!SWIG_IsOK(res1)) {
34950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34951 }
34952 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34953 result = (int) ((arg1)->h);
34954 resultobj = SWIG_From_int(static_cast< int >(result));
34955 return resultobj;
34956 fail:
34957 return NULL;
34958 }
34959
34960
34961 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34962 PyObject *resultobj = 0;
34963 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34964 int arg2 ;
34965 void *argp1 = 0 ;
34966 int res1 = 0 ;
34967 int val2 ;
34968 int ecode2 = 0 ;
34969 PyObject *swig_obj[2] ;
34970
34971 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34973 if (!SWIG_IsOK(res1)) {
34974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34975 }
34976 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34977 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34978 if (!SWIG_IsOK(ecode2)) {
34979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34980 }
34981 arg2 = static_cast< int >(val2);
34982 if (arg1) (arg1)->bpp = arg2;
34983
34984 resultobj = SWIG_Py_Void();
34985 return resultobj;
34986 fail:
34987 return NULL;
34988 }
34989
34990
34991 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34992 PyObject *resultobj = 0;
34993 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34994 int result;
34995 void *argp1 = 0 ;
34996 int res1 = 0 ;
34997 PyObject *swig_obj[1] ;
34998
34999 if (!args) SWIG_fail;
35000 swig_obj[0] = args;
35001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35002 if (!SWIG_IsOK(res1)) {
35003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35004 }
35005 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35006 result = (int) ((arg1)->bpp);
35007 resultobj = SWIG_From_int(static_cast< int >(result));
35008 return resultobj;
35009 fail:
35010 return NULL;
35011 }
35012
35013
35014 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35015 PyObject *resultobj = 0;
35016 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35017 int arg2 ;
35018 void *argp1 = 0 ;
35019 int res1 = 0 ;
35020 int val2 ;
35021 int ecode2 = 0 ;
35022 PyObject *swig_obj[2] ;
35023
35024 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35026 if (!SWIG_IsOK(res1)) {
35027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35028 }
35029 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35030 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35031 if (!SWIG_IsOK(ecode2)) {
35032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35033 }
35034 arg2 = static_cast< int >(val2);
35035 if (arg1) (arg1)->refresh = arg2;
35036
35037 resultobj = SWIG_Py_Void();
35038 return resultobj;
35039 fail:
35040 return NULL;
35041 }
35042
35043
35044 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35045 PyObject *resultobj = 0;
35046 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35047 int result;
35048 void *argp1 = 0 ;
35049 int res1 = 0 ;
35050 PyObject *swig_obj[1] ;
35051
35052 if (!args) SWIG_fail;
35053 swig_obj[0] = args;
35054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35055 if (!SWIG_IsOK(res1)) {
35056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35057 }
35058 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35059 result = (int) ((arg1)->refresh);
35060 resultobj = SWIG_From_int(static_cast< int >(result));
35061 return resultobj;
35062 fail:
35063 return NULL;
35064 }
35065
35066
35067 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35068 PyObject *obj;
35069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35070 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35071 return SWIG_Py_Void();
35072 }
35073
35074 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35075 return SWIG_Python_InitShadowInstance(args);
35076 }
35077
35078 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35079 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35080 return 1;
35081 }
35082
35083
35084 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35085 PyObject *pyobj = 0;
35086
35087 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35088 return pyobj;
35089 }
35090
35091
35092 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35093 PyObject *resultobj = 0;
35094 size_t arg1 = (size_t) 0 ;
35095 wxDisplay *result = 0 ;
35096 size_t val1 ;
35097 int ecode1 = 0 ;
35098 PyObject * obj0 = 0 ;
35099 char * kwnames[] = {
35100 (char *) "index", NULL
35101 };
35102
35103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35104 if (obj0) {
35105 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35106 if (!SWIG_IsOK(ecode1)) {
35107 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35108 }
35109 arg1 = static_cast< size_t >(val1);
35110 }
35111 {
35112 PyThreadState* __tstate = wxPyBeginAllowThreads();
35113 result = (wxDisplay *)new wxDisplay(arg1);
35114 wxPyEndAllowThreads(__tstate);
35115 if (PyErr_Occurred()) SWIG_fail;
35116 }
35117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35118 return resultobj;
35119 fail:
35120 return NULL;
35121 }
35122
35123
35124 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35125 PyObject *resultobj = 0;
35126 wxDisplay *arg1 = (wxDisplay *) 0 ;
35127 void *argp1 = 0 ;
35128 int res1 = 0 ;
35129 PyObject *swig_obj[1] ;
35130
35131 if (!args) SWIG_fail;
35132 swig_obj[0] = args;
35133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35134 if (!SWIG_IsOK(res1)) {
35135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35136 }
35137 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35138 {
35139 PyThreadState* __tstate = wxPyBeginAllowThreads();
35140 delete arg1;
35141
35142 wxPyEndAllowThreads(__tstate);
35143 if (PyErr_Occurred()) SWIG_fail;
35144 }
35145 resultobj = SWIG_Py_Void();
35146 return resultobj;
35147 fail:
35148 return NULL;
35149 }
35150
35151
35152 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35153 PyObject *resultobj = 0;
35154 size_t result;
35155
35156 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35157 {
35158 PyThreadState* __tstate = wxPyBeginAllowThreads();
35159 result = (size_t)wxDisplay::GetCount();
35160 wxPyEndAllowThreads(__tstate);
35161 if (PyErr_Occurred()) SWIG_fail;
35162 }
35163 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35164 return resultobj;
35165 fail:
35166 return NULL;
35167 }
35168
35169
35170 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35171 PyObject *resultobj = 0;
35172 wxPoint *arg1 = 0 ;
35173 int result;
35174 wxPoint temp1 ;
35175 PyObject * obj0 = 0 ;
35176 char * kwnames[] = {
35177 (char *) "pt", NULL
35178 };
35179
35180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35181 {
35182 arg1 = &temp1;
35183 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35184 }
35185 {
35186 PyThreadState* __tstate = wxPyBeginAllowThreads();
35187 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35188 wxPyEndAllowThreads(__tstate);
35189 if (PyErr_Occurred()) SWIG_fail;
35190 }
35191 resultobj = SWIG_From_int(static_cast< int >(result));
35192 return resultobj;
35193 fail:
35194 return NULL;
35195 }
35196
35197
35198 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35199 PyObject *resultobj = 0;
35200 wxWindow *arg1 = (wxWindow *) 0 ;
35201 int result;
35202 void *argp1 = 0 ;
35203 int res1 = 0 ;
35204 PyObject * obj0 = 0 ;
35205 char * kwnames[] = {
35206 (char *) "window", NULL
35207 };
35208
35209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35211 if (!SWIG_IsOK(res1)) {
35212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35213 }
35214 arg1 = reinterpret_cast< wxWindow * >(argp1);
35215 {
35216 PyThreadState* __tstate = wxPyBeginAllowThreads();
35217 result = (int)wxDisplay::GetFromWindow(arg1);
35218 wxPyEndAllowThreads(__tstate);
35219 if (PyErr_Occurred()) SWIG_fail;
35220 }
35221 resultobj = SWIG_From_int(static_cast< int >(result));
35222 return resultobj;
35223 fail:
35224 return NULL;
35225 }
35226
35227
35228 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35229 PyObject *resultobj = 0;
35230 wxDisplay *arg1 = (wxDisplay *) 0 ;
35231 bool result;
35232 void *argp1 = 0 ;
35233 int res1 = 0 ;
35234 PyObject *swig_obj[1] ;
35235
35236 if (!args) SWIG_fail;
35237 swig_obj[0] = args;
35238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35239 if (!SWIG_IsOK(res1)) {
35240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35241 }
35242 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 result = (bool)((wxDisplay const *)arg1)->IsOk();
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 {
35250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35251 }
35252 return resultobj;
35253 fail:
35254 return NULL;
35255 }
35256
35257
35258 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35259 PyObject *resultobj = 0;
35260 wxDisplay *arg1 = (wxDisplay *) 0 ;
35261 wxRect result;
35262 void *argp1 = 0 ;
35263 int res1 = 0 ;
35264 PyObject *swig_obj[1] ;
35265
35266 if (!args) SWIG_fail;
35267 swig_obj[0] = args;
35268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35269 if (!SWIG_IsOK(res1)) {
35270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35271 }
35272 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35273 {
35274 PyThreadState* __tstate = wxPyBeginAllowThreads();
35275 result = ((wxDisplay const *)arg1)->GetGeometry();
35276 wxPyEndAllowThreads(__tstate);
35277 if (PyErr_Occurred()) SWIG_fail;
35278 }
35279 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35280 return resultobj;
35281 fail:
35282 return NULL;
35283 }
35284
35285
35286 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35287 PyObject *resultobj = 0;
35288 wxDisplay *arg1 = (wxDisplay *) 0 ;
35289 wxRect result;
35290 void *argp1 = 0 ;
35291 int res1 = 0 ;
35292 PyObject *swig_obj[1] ;
35293
35294 if (!args) SWIG_fail;
35295 swig_obj[0] = args;
35296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35297 if (!SWIG_IsOK(res1)) {
35298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35299 }
35300 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35301 {
35302 PyThreadState* __tstate = wxPyBeginAllowThreads();
35303 result = ((wxDisplay const *)arg1)->GetClientArea();
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35315 PyObject *resultobj = 0;
35316 wxDisplay *arg1 = (wxDisplay *) 0 ;
35317 wxString result;
35318 void *argp1 = 0 ;
35319 int res1 = 0 ;
35320 PyObject *swig_obj[1] ;
35321
35322 if (!args) SWIG_fail;
35323 swig_obj[0] = args;
35324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35325 if (!SWIG_IsOK(res1)) {
35326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35327 }
35328 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = ((wxDisplay const *)arg1)->GetName();
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 {
35336 #if wxUSE_UNICODE
35337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35338 #else
35339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35340 #endif
35341 }
35342 return resultobj;
35343 fail:
35344 return NULL;
35345 }
35346
35347
35348 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35349 PyObject *resultobj = 0;
35350 wxDisplay *arg1 = (wxDisplay *) 0 ;
35351 bool result;
35352 void *argp1 = 0 ;
35353 int res1 = 0 ;
35354 PyObject *swig_obj[1] ;
35355
35356 if (!args) SWIG_fail;
35357 swig_obj[0] = args;
35358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35359 if (!SWIG_IsOK(res1)) {
35360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35361 }
35362 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35363 {
35364 PyThreadState* __tstate = wxPyBeginAllowThreads();
35365 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35366 wxPyEndAllowThreads(__tstate);
35367 if (PyErr_Occurred()) SWIG_fail;
35368 }
35369 {
35370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35371 }
35372 return resultobj;
35373 fail:
35374 return NULL;
35375 }
35376
35377
35378 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35379 PyObject *resultobj = 0;
35380 wxDisplay *arg1 = (wxDisplay *) 0 ;
35381 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35382 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35383 PyObject *result = 0 ;
35384 void *argp1 = 0 ;
35385 int res1 = 0 ;
35386 void *argp2 = 0 ;
35387 int res2 = 0 ;
35388 PyObject * obj0 = 0 ;
35389 PyObject * obj1 = 0 ;
35390 char * kwnames[] = {
35391 (char *) "self",(char *) "mode", NULL
35392 };
35393
35394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35396 if (!SWIG_IsOK(res1)) {
35397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35398 }
35399 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35400 if (obj1) {
35401 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35402 if (!SWIG_IsOK(res2)) {
35403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35404 }
35405 if (!argp2) {
35406 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35407 }
35408 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35409 }
35410 {
35411 PyThreadState* __tstate = wxPyBeginAllowThreads();
35412 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35413 wxPyEndAllowThreads(__tstate);
35414 if (PyErr_Occurred()) SWIG_fail;
35415 }
35416 resultobj = result;
35417 return resultobj;
35418 fail:
35419 return NULL;
35420 }
35421
35422
35423 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35424 PyObject *resultobj = 0;
35425 wxDisplay *arg1 = (wxDisplay *) 0 ;
35426 wxVideoMode result;
35427 void *argp1 = 0 ;
35428 int res1 = 0 ;
35429 PyObject *swig_obj[1] ;
35430
35431 if (!args) SWIG_fail;
35432 swig_obj[0] = args;
35433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35434 if (!SWIG_IsOK(res1)) {
35435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35436 }
35437 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35438 {
35439 PyThreadState* __tstate = wxPyBeginAllowThreads();
35440 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35441 wxPyEndAllowThreads(__tstate);
35442 if (PyErr_Occurred()) SWIG_fail;
35443 }
35444 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35445 return resultobj;
35446 fail:
35447 return NULL;
35448 }
35449
35450
35451 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35452 PyObject *resultobj = 0;
35453 wxDisplay *arg1 = (wxDisplay *) 0 ;
35454 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35455 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35456 bool result;
35457 void *argp1 = 0 ;
35458 int res1 = 0 ;
35459 void *argp2 = 0 ;
35460 int res2 = 0 ;
35461 PyObject * obj0 = 0 ;
35462 PyObject * obj1 = 0 ;
35463 char * kwnames[] = {
35464 (char *) "self",(char *) "mode", NULL
35465 };
35466
35467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35469 if (!SWIG_IsOK(res1)) {
35470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35471 }
35472 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35473 if (obj1) {
35474 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35475 if (!SWIG_IsOK(res2)) {
35476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35477 }
35478 if (!argp2) {
35479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35480 }
35481 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35482 }
35483 {
35484 PyThreadState* __tstate = wxPyBeginAllowThreads();
35485 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35486 wxPyEndAllowThreads(__tstate);
35487 if (PyErr_Occurred()) SWIG_fail;
35488 }
35489 {
35490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35491 }
35492 return resultobj;
35493 fail:
35494 return NULL;
35495 }
35496
35497
35498 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35499 PyObject *resultobj = 0;
35500 wxDisplay *arg1 = (wxDisplay *) 0 ;
35501 void *argp1 = 0 ;
35502 int res1 = 0 ;
35503 PyObject *swig_obj[1] ;
35504
35505 if (!args) SWIG_fail;
35506 swig_obj[0] = args;
35507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35508 if (!SWIG_IsOK(res1)) {
35509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35510 }
35511 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 wxDisplay_ResetMode(arg1);
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 resultobj = SWIG_Py_Void();
35519 return resultobj;
35520 fail:
35521 return NULL;
35522 }
35523
35524
35525 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35526 PyObject *obj;
35527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35528 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35529 return SWIG_Py_Void();
35530 }
35531
35532 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35533 return SWIG_Python_InitShadowInstance(args);
35534 }
35535
35536 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35537 PyObject *resultobj = 0;
35538 wxStandardPaths *result = 0 ;
35539
35540 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35541 {
35542 PyThreadState* __tstate = wxPyBeginAllowThreads();
35543 result = (wxStandardPaths *)wxStandardPaths_Get();
35544 wxPyEndAllowThreads(__tstate);
35545 if (PyErr_Occurred()) SWIG_fail;
35546 }
35547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35548 return resultobj;
35549 fail:
35550 return NULL;
35551 }
35552
35553
35554 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35555 PyObject *resultobj = 0;
35556 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35557 wxString result;
35558 void *argp1 = 0 ;
35559 int res1 = 0 ;
35560 PyObject *swig_obj[1] ;
35561
35562 if (!args) SWIG_fail;
35563 swig_obj[0] = args;
35564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35565 if (!SWIG_IsOK(res1)) {
35566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35567 }
35568 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35569 {
35570 PyThreadState* __tstate = wxPyBeginAllowThreads();
35571 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35572 wxPyEndAllowThreads(__tstate);
35573 if (PyErr_Occurred()) SWIG_fail;
35574 }
35575 {
35576 #if wxUSE_UNICODE
35577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35578 #else
35579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35580 #endif
35581 }
35582 return resultobj;
35583 fail:
35584 return NULL;
35585 }
35586
35587
35588 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35589 PyObject *resultobj = 0;
35590 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35591 wxString result;
35592 void *argp1 = 0 ;
35593 int res1 = 0 ;
35594 PyObject *swig_obj[1] ;
35595
35596 if (!args) SWIG_fail;
35597 swig_obj[0] = args;
35598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35599 if (!SWIG_IsOK(res1)) {
35600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35601 }
35602 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35603 {
35604 PyThreadState* __tstate = wxPyBeginAllowThreads();
35605 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35606 wxPyEndAllowThreads(__tstate);
35607 if (PyErr_Occurred()) SWIG_fail;
35608 }
35609 {
35610 #if wxUSE_UNICODE
35611 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35612 #else
35613 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35614 #endif
35615 }
35616 return resultobj;
35617 fail:
35618 return NULL;
35619 }
35620
35621
35622 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35623 PyObject *resultobj = 0;
35624 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35625 wxString result;
35626 void *argp1 = 0 ;
35627 int res1 = 0 ;
35628 PyObject *swig_obj[1] ;
35629
35630 if (!args) SWIG_fail;
35631 swig_obj[0] = args;
35632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35633 if (!SWIG_IsOK(res1)) {
35634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35635 }
35636 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35637 {
35638 PyThreadState* __tstate = wxPyBeginAllowThreads();
35639 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35640 wxPyEndAllowThreads(__tstate);
35641 if (PyErr_Occurred()) SWIG_fail;
35642 }
35643 {
35644 #if wxUSE_UNICODE
35645 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35646 #else
35647 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35648 #endif
35649 }
35650 return resultobj;
35651 fail:
35652 return NULL;
35653 }
35654
35655
35656 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35657 PyObject *resultobj = 0;
35658 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35659 wxString result;
35660 void *argp1 = 0 ;
35661 int res1 = 0 ;
35662 PyObject *swig_obj[1] ;
35663
35664 if (!args) SWIG_fail;
35665 swig_obj[0] = args;
35666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35667 if (!SWIG_IsOK(res1)) {
35668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35669 }
35670 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35671 {
35672 PyThreadState* __tstate = wxPyBeginAllowThreads();
35673 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35674 wxPyEndAllowThreads(__tstate);
35675 if (PyErr_Occurred()) SWIG_fail;
35676 }
35677 {
35678 #if wxUSE_UNICODE
35679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35680 #else
35681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35682 #endif
35683 }
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35691 PyObject *resultobj = 0;
35692 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35693 wxString result;
35694 void *argp1 = 0 ;
35695 int res1 = 0 ;
35696 PyObject *swig_obj[1] ;
35697
35698 if (!args) SWIG_fail;
35699 swig_obj[0] = args;
35700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35701 if (!SWIG_IsOK(res1)) {
35702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35703 }
35704 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35705 {
35706 PyThreadState* __tstate = wxPyBeginAllowThreads();
35707 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35708 wxPyEndAllowThreads(__tstate);
35709 if (PyErr_Occurred()) SWIG_fail;
35710 }
35711 {
35712 #if wxUSE_UNICODE
35713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35714 #else
35715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35716 #endif
35717 }
35718 return resultobj;
35719 fail:
35720 return NULL;
35721 }
35722
35723
35724 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35725 PyObject *resultobj = 0;
35726 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35727 wxString result;
35728 void *argp1 = 0 ;
35729 int res1 = 0 ;
35730 PyObject *swig_obj[1] ;
35731
35732 if (!args) SWIG_fail;
35733 swig_obj[0] = args;
35734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35735 if (!SWIG_IsOK(res1)) {
35736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35737 }
35738 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35739 {
35740 PyThreadState* __tstate = wxPyBeginAllowThreads();
35741 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35742 wxPyEndAllowThreads(__tstate);
35743 if (PyErr_Occurred()) SWIG_fail;
35744 }
35745 {
35746 #if wxUSE_UNICODE
35747 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35748 #else
35749 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35750 #endif
35751 }
35752 return resultobj;
35753 fail:
35754 return NULL;
35755 }
35756
35757
35758 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35759 PyObject *resultobj = 0;
35760 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35761 wxString result;
35762 void *argp1 = 0 ;
35763 int res1 = 0 ;
35764 PyObject *swig_obj[1] ;
35765
35766 if (!args) SWIG_fail;
35767 swig_obj[0] = args;
35768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35769 if (!SWIG_IsOK(res1)) {
35770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35771 }
35772 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35773 {
35774 PyThreadState* __tstate = wxPyBeginAllowThreads();
35775 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35776 wxPyEndAllowThreads(__tstate);
35777 if (PyErr_Occurred()) SWIG_fail;
35778 }
35779 {
35780 #if wxUSE_UNICODE
35781 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35782 #else
35783 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35784 #endif
35785 }
35786 return resultobj;
35787 fail:
35788 return NULL;
35789 }
35790
35791
35792 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35793 PyObject *resultobj = 0;
35794 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35795 wxString result;
35796 void *argp1 = 0 ;
35797 int res1 = 0 ;
35798 PyObject *swig_obj[1] ;
35799
35800 if (!args) SWIG_fail;
35801 swig_obj[0] = args;
35802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35803 if (!SWIG_IsOK(res1)) {
35804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35805 }
35806 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35807 {
35808 PyThreadState* __tstate = wxPyBeginAllowThreads();
35809 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35810 wxPyEndAllowThreads(__tstate);
35811 if (PyErr_Occurred()) SWIG_fail;
35812 }
35813 {
35814 #if wxUSE_UNICODE
35815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35816 #else
35817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35818 #endif
35819 }
35820 return resultobj;
35821 fail:
35822 return NULL;
35823 }
35824
35825
35826 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35827 PyObject *resultobj = 0;
35828 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35829 wxString *arg2 = 0 ;
35830 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35831 wxString result;
35832 void *argp1 = 0 ;
35833 int res1 = 0 ;
35834 bool temp2 = false ;
35835 int val3 ;
35836 int ecode3 = 0 ;
35837 PyObject * obj0 = 0 ;
35838 PyObject * obj1 = 0 ;
35839 PyObject * obj2 = 0 ;
35840 char * kwnames[] = {
35841 (char *) "self",(char *) "lang",(char *) "category", NULL
35842 };
35843
35844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35846 if (!SWIG_IsOK(res1)) {
35847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35848 }
35849 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35850 {
35851 arg2 = wxString_in_helper(obj1);
35852 if (arg2 == NULL) SWIG_fail;
35853 temp2 = true;
35854 }
35855 if (obj2) {
35856 ecode3 = SWIG_AsVal_int(obj2, &val3);
35857 if (!SWIG_IsOK(ecode3)) {
35858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35859 }
35860 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35861 }
35862 {
35863 PyThreadState* __tstate = wxPyBeginAllowThreads();
35864 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35865 wxPyEndAllowThreads(__tstate);
35866 if (PyErr_Occurred()) SWIG_fail;
35867 }
35868 {
35869 #if wxUSE_UNICODE
35870 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35871 #else
35872 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35873 #endif
35874 }
35875 {
35876 if (temp2)
35877 delete arg2;
35878 }
35879 return resultobj;
35880 fail:
35881 {
35882 if (temp2)
35883 delete arg2;
35884 }
35885 return NULL;
35886 }
35887
35888
35889 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35890 PyObject *resultobj = 0;
35891 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35892 wxString result;
35893 void *argp1 = 0 ;
35894 int res1 = 0 ;
35895 PyObject *swig_obj[1] ;
35896
35897 if (!args) SWIG_fail;
35898 swig_obj[0] = args;
35899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35900 if (!SWIG_IsOK(res1)) {
35901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35902 }
35903 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35904 {
35905 PyThreadState* __tstate = wxPyBeginAllowThreads();
35906 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
35907 wxPyEndAllowThreads(__tstate);
35908 if (PyErr_Occurred()) SWIG_fail;
35909 }
35910 {
35911 #if wxUSE_UNICODE
35912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35913 #else
35914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35915 #endif
35916 }
35917 return resultobj;
35918 fail:
35919 return NULL;
35920 }
35921
35922
35923 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35924 PyObject *resultobj = 0;
35925 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35926 wxString *arg2 = 0 ;
35927 void *argp1 = 0 ;
35928 int res1 = 0 ;
35929 bool temp2 = false ;
35930 PyObject * obj0 = 0 ;
35931 PyObject * obj1 = 0 ;
35932 char * kwnames[] = {
35933 (char *) "self",(char *) "prefix", NULL
35934 };
35935
35936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35938 if (!SWIG_IsOK(res1)) {
35939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35940 }
35941 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35942 {
35943 arg2 = wxString_in_helper(obj1);
35944 if (arg2 == NULL) SWIG_fail;
35945 temp2 = true;
35946 }
35947 {
35948 PyThreadState* __tstate = wxPyBeginAllowThreads();
35949 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
35950 wxPyEndAllowThreads(__tstate);
35951 if (PyErr_Occurred()) SWIG_fail;
35952 }
35953 resultobj = SWIG_Py_Void();
35954 {
35955 if (temp2)
35956 delete arg2;
35957 }
35958 return resultobj;
35959 fail:
35960 {
35961 if (temp2)
35962 delete arg2;
35963 }
35964 return NULL;
35965 }
35966
35967
35968 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35969 PyObject *resultobj = 0;
35970 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35971 wxString result;
35972 void *argp1 = 0 ;
35973 int res1 = 0 ;
35974 PyObject *swig_obj[1] ;
35975
35976 if (!args) SWIG_fail;
35977 swig_obj[0] = args;
35978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35979 if (!SWIG_IsOK(res1)) {
35980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35981 }
35982 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 result = wxStandardPaths_GetInstallPrefix(arg1);
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 {
35990 #if wxUSE_UNICODE
35991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35992 #else
35993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35994 #endif
35995 }
35996 return resultobj;
35997 fail:
35998 return NULL;
35999 }
36000
36001
36002 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36003 PyObject *obj;
36004 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36005 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
36006 return SWIG_Py_Void();
36007 }
36008
36009 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36010 PyObject *resultobj = 0;
36011 wxEventType arg1 ;
36012 wxPowerEvent *result = 0 ;
36013 int val1 ;
36014 int ecode1 = 0 ;
36015 PyObject * obj0 = 0 ;
36016 char * kwnames[] = {
36017 (char *) "evtType", NULL
36018 };
36019
36020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
36021 ecode1 = SWIG_AsVal_int(obj0, &val1);
36022 if (!SWIG_IsOK(ecode1)) {
36023 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
36024 }
36025 arg1 = static_cast< wxEventType >(val1);
36026 {
36027 PyThreadState* __tstate = wxPyBeginAllowThreads();
36028 result = (wxPowerEvent *)new wxPowerEvent(arg1);
36029 wxPyEndAllowThreads(__tstate);
36030 if (PyErr_Occurred()) SWIG_fail;
36031 }
36032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
36033 return resultobj;
36034 fail:
36035 return NULL;
36036 }
36037
36038
36039 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36040 PyObject *resultobj = 0;
36041 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36042 void *argp1 = 0 ;
36043 int res1 = 0 ;
36044 PyObject *swig_obj[1] ;
36045
36046 if (!args) SWIG_fail;
36047 swig_obj[0] = args;
36048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36049 if (!SWIG_IsOK(res1)) {
36050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36051 }
36052 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36053 {
36054 PyThreadState* __tstate = wxPyBeginAllowThreads();
36055 (arg1)->Veto();
36056 wxPyEndAllowThreads(__tstate);
36057 if (PyErr_Occurred()) SWIG_fail;
36058 }
36059 resultobj = SWIG_Py_Void();
36060 return resultobj;
36061 fail:
36062 return NULL;
36063 }
36064
36065
36066 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36067 PyObject *resultobj = 0;
36068 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36069 bool result;
36070 void *argp1 = 0 ;
36071 int res1 = 0 ;
36072 PyObject *swig_obj[1] ;
36073
36074 if (!args) SWIG_fail;
36075 swig_obj[0] = args;
36076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36077 if (!SWIG_IsOK(res1)) {
36078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36079 }
36080 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36081 {
36082 PyThreadState* __tstate = wxPyBeginAllowThreads();
36083 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36084 wxPyEndAllowThreads(__tstate);
36085 if (PyErr_Occurred()) SWIG_fail;
36086 }
36087 {
36088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36089 }
36090 return resultobj;
36091 fail:
36092 return NULL;
36093 }
36094
36095
36096 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36097 PyObject *obj;
36098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36099 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36100 return SWIG_Py_Void();
36101 }
36102
36103 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36104 return SWIG_Python_InitShadowInstance(args);
36105 }
36106
36107 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36108 PyObject *resultobj = 0;
36109 wxPowerType result;
36110
36111 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36112 {
36113 PyThreadState* __tstate = wxPyBeginAllowThreads();
36114 result = (wxPowerType)wxGetPowerType();
36115 wxPyEndAllowThreads(__tstate);
36116 if (PyErr_Occurred()) SWIG_fail;
36117 }
36118 resultobj = SWIG_From_int(static_cast< int >(result));
36119 return resultobj;
36120 fail:
36121 return NULL;
36122 }
36123
36124
36125 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36126 PyObject *resultobj = 0;
36127 wxBatteryState result;
36128
36129 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36130 {
36131 PyThreadState* __tstate = wxPyBeginAllowThreads();
36132 result = (wxBatteryState)wxGetBatteryState();
36133 wxPyEndAllowThreads(__tstate);
36134 if (PyErr_Occurred()) SWIG_fail;
36135 }
36136 resultobj = SWIG_From_int(static_cast< int >(result));
36137 return resultobj;
36138 fail:
36139 return NULL;
36140 }
36141
36142
36143 static PyMethodDef SwigMethods[] = {
36144 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36145 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36146 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36147 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36148 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36149 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36150 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36151 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36152 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36153 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36154 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36155 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36156 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36157 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36158 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36159 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36160 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36161 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36162 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36163 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36164 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36165 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36166 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36167 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36168 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36169 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36170 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36171 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36172 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36173 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36174 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36175 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36176 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36177 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36178 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36179 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36180 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36181 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36182 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36183 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36184 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36185 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36186 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36187 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36188 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36189 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36190 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36191 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36192 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36193 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36194 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36195 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36196 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36197 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36198 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36199 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36200 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36201 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36202 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36203 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36204 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36205 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36206 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36207 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36208 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36209 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36210 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36211 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36212 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36213 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36214 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36215 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36216 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36217 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36218 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36219 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36220 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36221 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36222 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36223 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36224 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36225 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36226 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36227 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36228 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36229 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36230 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36231 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36232 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36233 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36234 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36235 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36236 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36237 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36238 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36239 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36240 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36241 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36242 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36243 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36244 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36245 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36246 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36247 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36248 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36249 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36250 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36251 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36252 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36253 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36254 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36255 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36256 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36257 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36258 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36259 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36260 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36261 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36262 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36263 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36264 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36265 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36266 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36267 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36268 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36269 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36270 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36271 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36272 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36273 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36274 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36275 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36277 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36278 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36280 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36281 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36282 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36283 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36284 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36285 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36287 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36288 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36289 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36290 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36291 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36292 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36293 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36294 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36295 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36296 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36297 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36298 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36299 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36300 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36301 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36302 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36304 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36305 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36306 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36307 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36308 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36309 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36310 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36313 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36314 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36315 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36316 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36317 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36318 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36320 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36321 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36322 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36324 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36325 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36326 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36328 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36329 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36331 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36332 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36333 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36334 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36335 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36336 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36337 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36338 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36339 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36341 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36342 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36343 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36344 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36345 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36346 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36347 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36348 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36349 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36350 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36351 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36352 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36353 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36354 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36355 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36356 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36357 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36358 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36359 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36360 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36363 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36364 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36365 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36367 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36368 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36370 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36371 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36375 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36376 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36377 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36378 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36379 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36380 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36381 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36382 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36383 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36384 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36385 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36386 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36387 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36388 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36389 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36390 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36391 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36392 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36393 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36394 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36395 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36396 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36397 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36398 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36399 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36400 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36402 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36403 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36404 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36405 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36406 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36407 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36408 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36409 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36410 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36411 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36412 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36413 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36414 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36415 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36419 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36420 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36421 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36422 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36423 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36424 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36425 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36426 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36427 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36428 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36430 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36431 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36432 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36433 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36434 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36436 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36437 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36438 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36439 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36440 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36441 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36442 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36443 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36444 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36445 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36446 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36447 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36448 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36449 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36450 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36451 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36452 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36453 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36454 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36455 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36457 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36458 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36459 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36460 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36461 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36462 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36463 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36464 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36465 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36466 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36468 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36469 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36470 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36471 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36472 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36473 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36474 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36475 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36476 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36477 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36479 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36480 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36481 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36482 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36483 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36484 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36485 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36486 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36487 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36488 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36489 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36490 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36491 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36492 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36493 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36494 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36495 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36496 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36497 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36498 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36499 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36500 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36501 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36502 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36503 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36504 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36505 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36506 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36507 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36508 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36509 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36510 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36511 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36512 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36514 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36515 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36516 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36517 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36518 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36519 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36524 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36525 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36526 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36527 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36528 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36530 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36531 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36533 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36534 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36535 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36537 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36538 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36539 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36540 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36541 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36542 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36545 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36546 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36549 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36550 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36551 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36552 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36553 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36554 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36555 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36556 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36557 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36558 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36559 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36560 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36561 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36562 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36563 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36564 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36565 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36566 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36567 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36569 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36570 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36573 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36574 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36575 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36576 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36577 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36578 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36579 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36580 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36582 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36583 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36584 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36585 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36588 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36589 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36590 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36591 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36592 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36593 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36594 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36595 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36596 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36597 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36599 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36600 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36601 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36602 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36603 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36604 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36605 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36606 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36607 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36608 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36609 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36610 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36611 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36612 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36613 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36614 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36615 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36616 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36617 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36618 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36619 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36621 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36622 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36623 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36624 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36625 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36626 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36628 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36629 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36630 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36631 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36632 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36633 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36634 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36635 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36636 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36637 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36638 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36639 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36640 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36641 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36642 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36643 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36645 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36646 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36648 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36649 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36650 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36651 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36652 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36653 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36654 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36656 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36657 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36658 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36659 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36660 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36661 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36662 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36663 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36665 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36666 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36667 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36668 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36669 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36670 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36671 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36672 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36673 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36674 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36675 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36676 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36677 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36678 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36679 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36680 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36681 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36682 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36683 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36684 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36685 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36686 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36687 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36688 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36689 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36690 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36691 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36692 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36693 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36698 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36700 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36701 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36702 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36703 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36705 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36709 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36710 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36711 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36712 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36714 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36715 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36716 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36717 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36718 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36719 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36720 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36721 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36722 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36723 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36724 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36725 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36726 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36727 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36728 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36729 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36731 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36732 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36733 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36734 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36735 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36736 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36737 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36738 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36742 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36753 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36759 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36760 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36761 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36762 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36763 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36764 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36765 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36766 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36770 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36771 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36772 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36773 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36774 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36775 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36776 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36777 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36778 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36779 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36780 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36781 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36782 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36783 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36784 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36785 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36786 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36787 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36788 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36789 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36790 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36792 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36793 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36794 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36797 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36798 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36799 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36802 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36803 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36804 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36805 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36809 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36810 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36811 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36812 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36814 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36815 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36816 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36817 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36820 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36821 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36822 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36823 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36824 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36825 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36826 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36827 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36828 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36830 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36831 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36832 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36834 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36835 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36836 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36837 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36838 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36839 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36841 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36842 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36843 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36844 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36845 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36846 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36847 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36848 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36849 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36850 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36852 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36853 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36854 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36856 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36857 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36858 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36859 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36860 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36861 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36862 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36863 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36864 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36865 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36866 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36867 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36868 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36869 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36870 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36871 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36872 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36873 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36874 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36875 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36877 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36878 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36879 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36881 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36882 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36883 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36884 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36885 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36886 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36887 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36888 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36889 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36890 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36891 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36892 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36893 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36894 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36895 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36896 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36898 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36899 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36900 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36901 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
36902 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36903 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36904 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36905 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36906 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36907 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36908 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36909 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36910 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36911 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36912 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36913 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36914 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36915 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36916 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36917 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36918 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36919 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36920 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36921 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36922 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36923 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36924 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36925 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36926 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36927 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36928 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36929 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36930 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36931 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36932 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36933 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36934 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36935 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36936 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36937 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36938 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36939 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36940 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
36941 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
36942 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36943 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36944 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36945 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36946 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36947 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36948 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36949 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36950 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36951 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36952 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36953 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36954 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36955 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36956 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36957 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36958 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36959 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36960 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36961 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36962 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36963 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36964 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36965 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36966 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36967 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36968 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36969 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36970 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36971 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36972 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36973 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36974 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36975 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36976 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36977 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36978 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36979 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36980 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36981 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36982 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36983 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36984 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36985 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36986 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36987 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36988 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36989 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36990 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36991 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36992 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36993 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36994 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36995 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36996 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36997 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36998 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36999 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
37000 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
37001 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
37002 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
37003 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
37004 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
37005 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
37006 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
37007 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
37008 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
37009 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
37010 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
37011 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
37012 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
37013 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
37014 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
37015 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
37016 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37017 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37018 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
37019 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
37020 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
37021 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
37022 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
37023 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
37024 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
37025 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
37026 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
37027 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
37028 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
37029 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
37030 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
37031 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37032 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37033 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
37034 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
37035 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
37036 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
37037 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
37038 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
37039 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
37040 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
37041 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
37042 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
37043 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
37044 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
37045 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
37046 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
37047 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
37048 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
37049 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
37050 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
37051 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37052 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37053 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37054 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37055 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37056 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37057 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37058 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37059 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37060 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37061 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37062 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37063 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37064 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37065 { NULL, NULL, 0, NULL }
37066 };
37067
37068
37069 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37070
37071 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37072 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37073 }
37074 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37075 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37076 }
37077 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37078 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37079 }
37080 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37081 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37082 }
37083 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37084 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37085 }
37086 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37087 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37088 }
37089 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37090 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37091 }
37092 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37093 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37094 }
37095 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37096 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37097 }
37098 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37099 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37100 }
37101 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37102 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37103 }
37104 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37105 return (void *)((wxEvent *) ((wxPyEvent *) x));
37106 }
37107 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37108 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37109 }
37110 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37111 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37112 }
37113 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37114 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37115 }
37116 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37117 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37118 }
37119 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37120 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37121 }
37122 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37123 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37124 }
37125 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37126 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37127 }
37128 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37129 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37130 }
37131 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37132 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37133 }
37134 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37135 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37136 }
37137 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37138 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37139 }
37140 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37141 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37142 }
37143 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37144 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37145 }
37146 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37147 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37148 }
37149 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37150 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37151 }
37152 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37153 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37154 }
37155 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37156 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37157 }
37158 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37159 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37160 }
37161 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37162 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37163 }
37164 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37165 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37166 }
37167 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37168 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37169 }
37170 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37171 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37172 }
37173 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37174 return (void *)((wxEvent *) ((wxShowEvent *) x));
37175 }
37176 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37177 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37178 }
37179 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37180 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37181 }
37182 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37183 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37184 }
37185 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37186 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37187 }
37188 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37189 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37190 }
37191 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37192 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37193 }
37194 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37195 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37196 }
37197 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37198 return (void *)((wxConfigBase *) ((wxConfig *) x));
37199 }
37200 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37201 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37202 }
37203 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37204 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37205 }
37206 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37207 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37208 }
37209 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37210 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37211 }
37212 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37213 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37214 }
37215 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37216 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37217 }
37218 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37219 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37220 }
37221 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37222 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37223 }
37224 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37225 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37226 }
37227 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37228 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37229 }
37230 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37231 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37232 }
37233 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37234 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37235 }
37236 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37237 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37238 }
37239 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37240 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37241 }
37242 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37243 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37244 }
37245 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37246 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37247 }
37248 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37249 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37250 }
37251 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37252 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37253 }
37254 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37255 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37256 }
37257 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37258 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37259 }
37260 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37261 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37262 }
37263 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37264 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37265 }
37266 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37267 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37268 }
37269 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37270 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37271 }
37272 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37273 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37274 }
37275 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37276 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37277 }
37278 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37279 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37280 }
37281 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37282 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37283 }
37284 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37285 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37286 }
37287 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37288 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37289 }
37290 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37291 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37292 }
37293 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37294 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37295 }
37296 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37297 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37298 }
37299 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37300 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37301 }
37302 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37303 return (void *)((wxObject *) ((wxSizerItem *) x));
37304 }
37305 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37306 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37307 }
37308 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37309 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37310 }
37311 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37312 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37313 }
37314 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37315 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37316 }
37317 static void *_p_wxSizerTo_p_wxObject(void *x) {
37318 return (void *)((wxObject *) ((wxSizer *) x));
37319 }
37320 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37321 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37322 }
37323 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37324 return (void *)((wxObject *) ((wxFileHistory *) x));
37325 }
37326 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37327 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37328 }
37329 static void *_p_wxEventTo_p_wxObject(void *x) {
37330 return (void *)((wxObject *) ((wxEvent *) x));
37331 }
37332 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37333 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37334 }
37335 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37336 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37337 }
37338 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37339 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37340 }
37341 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37342 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37343 }
37344 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37345 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37346 }
37347 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37348 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37349 }
37350 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37351 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37352 }
37353 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37354 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37355 }
37356 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37357 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37358 }
37359 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37360 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37361 }
37362 static void *_p_wxControlTo_p_wxObject(void *x) {
37363 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37364 }
37365 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37366 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37367 }
37368 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37369 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37370 }
37371 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37372 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37373 }
37374 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37375 return (void *)((wxObject *) ((wxFSFile *) x));
37376 }
37377 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37378 return (void *)((wxObject *) ((wxClipboard *) x));
37379 }
37380 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37381 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37382 }
37383 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37384 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37385 }
37386 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37387 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37388 }
37389 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37390 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37391 }
37392 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37393 return (void *)((wxObject *) ((wxToolTip *) x));
37394 }
37395 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37396 return (void *)((wxObject *) ((wxMenuItem *) x));
37397 }
37398 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37399 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37400 }
37401 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37402 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37403 }
37404 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37405 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37406 }
37407 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37408 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37409 }
37410 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37411 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37412 }
37413 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37414 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37415 }
37416 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37417 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37418 }
37419 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37420 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37421 }
37422 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37423 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37424 }
37425 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37426 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37427 }
37428 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37429 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37430 }
37431 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37432 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37433 }
37434 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37435 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37436 }
37437 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37438 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37439 }
37440 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37441 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37442 }
37443 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37444 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37445 }
37446 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37447 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37448 }
37449 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37450 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37451 }
37452 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37453 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37454 }
37455 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37456 return (void *)((wxObject *) ((wxImageHandler *) x));
37457 }
37458 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37459 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37460 }
37461 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37462 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37463 }
37464 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37465 return (void *)((wxObject *) ((wxEvtHandler *) x));
37466 }
37467 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37468 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37469 }
37470 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37471 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37472 }
37473 static void *_p_wxImageTo_p_wxObject(void *x) {
37474 return (void *)((wxObject *) ((wxImage *) x));
37475 }
37476 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37477 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37478 }
37479 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37480 return (void *)((wxObject *) ((wxSystemOptions *) x));
37481 }
37482 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37483 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37484 }
37485 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37486 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37487 }
37488 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37489 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37490 }
37491 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37492 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37493 }
37494 static void *_p_wxWindowTo_p_wxObject(void *x) {
37495 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37496 }
37497 static void *_p_wxMenuTo_p_wxObject(void *x) {
37498 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37499 }
37500 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37501 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37502 }
37503 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37504 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37505 }
37506 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37507 return (void *)((wxObject *) ((wxFileSystem *) x));
37508 }
37509 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37510 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37511 }
37512 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37513 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37514 }
37515 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37516 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37517 }
37518 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37519 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37520 }
37521 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37522 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37523 }
37524 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37525 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37526 }
37527 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37528 return (void *)((wxObject *) ((wxBusyInfo *) x));
37529 }
37530 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37531 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37532 }
37533 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37534 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37535 }
37536 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37537 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37538 }
37539 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37540 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37541 }
37542 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37543 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37544 }
37545 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37546 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37547 }
37548 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37549 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37550 }
37551 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37552 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37553 }
37554 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37555 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37556 }
37557 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37558 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37559 }
37560 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37561 return (void *)((wxLog *) ((wxLogBuffer *) x));
37562 }
37563 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37564 return (void *)((wxLog *) ((wxLogStderr *) x));
37565 }
37566 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37567 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37568 }
37569 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37570 return (void *)((wxLog *) ((wxLogWindow *) x));
37571 }
37572 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37573 return (void *)((wxLog *) ((wxLogChain *) x));
37574 }
37575 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37576 return (void *)((wxLog *) ((wxLogGui *) x));
37577 }
37578 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37579 return (void *)((wxLog *) ((wxPyLog *) x));
37580 }
37581 static void *_p_wxControlTo_p_wxWindow(void *x) {
37582 return (void *)((wxWindow *) ((wxControl *) x));
37583 }
37584 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37585 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37586 }
37587 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37588 return (void *)((wxWindow *) ((wxMenuBar *) x));
37589 }
37590 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37591 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37592 }
37593 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37594 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37595 }
37596 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37597 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};
37598 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37599 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37600 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37601 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37602 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37603 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37604 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37605 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37606 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37607 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37608 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37609 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37610 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37611 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37612 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37613 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37614 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37615 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37616 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37617 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37618 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37619 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37620 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37621 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37622 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37623 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37624 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37625 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37626 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37627 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37628 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37629 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37630 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37631 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37632 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37633 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37634 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37635 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37636 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37637 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37638 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37639 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37640 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37641 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37642 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37643 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37644 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37645 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37646 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37647 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37648 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37649 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37650 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37651 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37652 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37653 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37654 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37655 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37656 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37657 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37658 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37659 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37660 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37661 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37662 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37663 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37664 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37665 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37666 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37667 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37668 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37669 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37670 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37671 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37672 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37673 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37674 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37675 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37676 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37677 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37678 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37679 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37680 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37681 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37682 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37683 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37684 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37685 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37686 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37687 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37688 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37689 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37690 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37691 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37692 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37693 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37694 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37695 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37696 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37697 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37698 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37699 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37700 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37701 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37702 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37703 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37704 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37705 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37706 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37707 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37708 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37709 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37710 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37711 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37712 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37713 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37714 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37715 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37716 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37717 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37718 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37719 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37720 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37721 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37722 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37723 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37724 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37725 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37726 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37727 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37728 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37729 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37730 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37731 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37732 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37733 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37734 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37735 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37736 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37737 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37738 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37739 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37740 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37741 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37742 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37743 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37744 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37745 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37746 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37747 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37748 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37749 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37750 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37751 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37752 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37753 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37754 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37755 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37756 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37757 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37758 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37759 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37760 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37761 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37762 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37763 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37764 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37765 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37766 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37767 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37768
37769 static swig_type_info *swig_type_initial[] = {
37770 &_swigt__p_char,
37771 &_swigt__p_form_ops_t,
37772 &_swigt__p_int,
37773 &_swigt__p_unsigned_char,
37774 &_swigt__p_unsigned_int,
37775 &_swigt__p_unsigned_long,
37776 &_swigt__p_void,
37777 &_swigt__p_wxANIHandler,
37778 &_swigt__p_wxAcceleratorTable,
37779 &_swigt__p_wxActivateEvent,
37780 &_swigt__p_wxArrayString,
37781 &_swigt__p_wxBMPHandler,
37782 &_swigt__p_wxBitmap,
37783 &_swigt__p_wxBitmapDataObject,
37784 &_swigt__p_wxBoxSizer,
37785 &_swigt__p_wxBusyCursor,
37786 &_swigt__p_wxBusyInfo,
37787 &_swigt__p_wxCURHandler,
37788 &_swigt__p_wxCaret,
37789 &_swigt__p_wxChar,
37790 &_swigt__p_wxChildFocusEvent,
37791 &_swigt__p_wxClipboard,
37792 &_swigt__p_wxClipboardLocker,
37793 &_swigt__p_wxClipboardTextEvent,
37794 &_swigt__p_wxCloseEvent,
37795 &_swigt__p_wxColour,
37796 &_swigt__p_wxCommandEvent,
37797 &_swigt__p_wxConfig,
37798 &_swigt__p_wxConfigBase,
37799 &_swigt__p_wxConfigPathChanger,
37800 &_swigt__p_wxContextMenuEvent,
37801 &_swigt__p_wxControl,
37802 &_swigt__p_wxControlWithItems,
37803 &_swigt__p_wxCursor,
37804 &_swigt__p_wxCustomDataObject,
37805 &_swigt__p_wxDC,
37806 &_swigt__p_wxDataFormat,
37807 &_swigt__p_wxDataObject,
37808 &_swigt__p_wxDataObjectComposite,
37809 &_swigt__p_wxDataObjectSimple,
37810 &_swigt__p_wxDateEvent,
37811 &_swigt__p_wxDateSpan,
37812 &_swigt__p_wxDateTime,
37813 &_swigt__p_wxDateTime__TimeZone,
37814 &_swigt__p_wxDisplay,
37815 &_swigt__p_wxDisplayChangedEvent,
37816 &_swigt__p_wxDropFilesEvent,
37817 &_swigt__p_wxDuplexMode,
37818 &_swigt__p_wxEraseEvent,
37819 &_swigt__p_wxEvent,
37820 &_swigt__p_wxEvtHandler,
37821 &_swigt__p_wxFSFile,
37822 &_swigt__p_wxFileConfig,
37823 &_swigt__p_wxFileDataObject,
37824 &_swigt__p_wxFileHistory,
37825 &_swigt__p_wxFileSystem,
37826 &_swigt__p_wxFileType,
37827 &_swigt__p_wxFileTypeInfo,
37828 &_swigt__p_wxFlexGridSizer,
37829 &_swigt__p_wxFocusEvent,
37830 &_swigt__p_wxFont,
37831 &_swigt__p_wxFrame,
37832 &_swigt__p_wxGBSizerItem,
37833 &_swigt__p_wxGIFHandler,
37834 &_swigt__p_wxGridBagSizer,
37835 &_swigt__p_wxGridSizer,
37836 &_swigt__p_wxICOHandler,
37837 &_swigt__p_wxIcon,
37838 &_swigt__p_wxIconizeEvent,
37839 &_swigt__p_wxIdleEvent,
37840 &_swigt__p_wxImage,
37841 &_swigt__p_wxImageHandler,
37842 &_swigt__p_wxIndividualLayoutConstraint,
37843 &_swigt__p_wxInitDialogEvent,
37844 &_swigt__p_wxJPEGHandler,
37845 &_swigt__p_wxJoystick,
37846 &_swigt__p_wxJoystickEvent,
37847 &_swigt__p_wxKeyEvent,
37848 &_swigt__p_wxKillError,
37849 &_swigt__p_wxLayoutConstraints,
37850 &_swigt__p_wxLog,
37851 &_swigt__p_wxLogBuffer,
37852 &_swigt__p_wxLogChain,
37853 &_swigt__p_wxLogGui,
37854 &_swigt__p_wxLogNull,
37855 &_swigt__p_wxLogStderr,
37856 &_swigt__p_wxLogTextCtrl,
37857 &_swigt__p_wxLogWindow,
37858 &_swigt__p_wxMaximizeEvent,
37859 &_swigt__p_wxMemorySize,
37860 &_swigt__p_wxMenu,
37861 &_swigt__p_wxMenuBar,
37862 &_swigt__p_wxMenuEvent,
37863 &_swigt__p_wxMenuItem,
37864 &_swigt__p_wxMetafile,
37865 &_swigt__p_wxMetafileDataObject,
37866 &_swigt__p_wxMimeTypesManager,
37867 &_swigt__p_wxMouseCaptureChangedEvent,
37868 &_swigt__p_wxMouseEvent,
37869 &_swigt__p_wxMouseState,
37870 &_swigt__p_wxMoveEvent,
37871 &_swigt__p_wxMutexGuiLocker,
37872 &_swigt__p_wxNavigationKeyEvent,
37873 &_swigt__p_wxNcPaintEvent,
37874 &_swigt__p_wxNotifyEvent,
37875 &_swigt__p_wxObject,
37876 &_swigt__p_wxOutputStream,
37877 &_swigt__p_wxPCXHandler,
37878 &_swigt__p_wxPNGHandler,
37879 &_swigt__p_wxPNMHandler,
37880 &_swigt__p_wxPaintEvent,
37881 &_swigt__p_wxPaletteChangedEvent,
37882 &_swigt__p_wxPaperSize,
37883 &_swigt__p_wxPoint,
37884 &_swigt__p_wxPowerEvent,
37885 &_swigt__p_wxProcessEvent,
37886 &_swigt__p_wxPyApp,
37887 &_swigt__p_wxPyArtProvider,
37888 &_swigt__p_wxPyBitmapDataObject,
37889 &_swigt__p_wxPyCommandEvent,
37890 &_swigt__p_wxPyDataObjectSimple,
37891 &_swigt__p_wxPyDropSource,
37892 &_swigt__p_wxPyDropTarget,
37893 &_swigt__p_wxPyEvent,
37894 &_swigt__p_wxPyFileDropTarget,
37895 &_swigt__p_wxPyImageHandler,
37896 &_swigt__p_wxPyLog,
37897 &_swigt__p_wxPyProcess,
37898 &_swigt__p_wxPySizer,
37899 &_swigt__p_wxPyTextDataObject,
37900 &_swigt__p_wxPyTextDropTarget,
37901 &_swigt__p_wxPyTimer,
37902 &_swigt__p_wxPyTipProvider,
37903 &_swigt__p_wxPyValidator,
37904 &_swigt__p_wxQueryNewPaletteEvent,
37905 &_swigt__p_wxRect,
37906 &_swigt__p_wxScrollEvent,
37907 &_swigt__p_wxScrollWinEvent,
37908 &_swigt__p_wxSetCursorEvent,
37909 &_swigt__p_wxShowEvent,
37910 &_swigt__p_wxSingleInstanceChecker,
37911 &_swigt__p_wxSize,
37912 &_swigt__p_wxSizeEvent,
37913 &_swigt__p_wxSizer,
37914 &_swigt__p_wxSizerItem,
37915 &_swigt__p_wxSound,
37916 &_swigt__p_wxStandardPaths,
37917 &_swigt__p_wxStaticBoxSizer,
37918 &_swigt__p_wxStdDialogButtonSizer,
37919 &_swigt__p_wxStopWatch,
37920 &_swigt__p_wxString,
37921 &_swigt__p_wxSysColourChangedEvent,
37922 &_swigt__p_wxSystemOptions,
37923 &_swigt__p_wxSystemSettings,
37924 &_swigt__p_wxTIFFHandler,
37925 &_swigt__p_wxTextCtrl,
37926 &_swigt__p_wxTextDataObject,
37927 &_swigt__p_wxTimeSpan,
37928 &_swigt__p_wxTimer,
37929 &_swigt__p_wxTimerEvent,
37930 &_swigt__p_wxTimerRunner,
37931 &_swigt__p_wxTipProvider,
37932 &_swigt__p_wxToolTip,
37933 &_swigt__p_wxURLDataObject,
37934 &_swigt__p_wxUpdateUIEvent,
37935 &_swigt__p_wxValidator,
37936 &_swigt__p_wxVideoMode,
37937 &_swigt__p_wxWindow,
37938 &_swigt__p_wxWindowCreateEvent,
37939 &_swigt__p_wxWindowDestroyEvent,
37940 &_swigt__p_wxWindowDisabler,
37941 &_swigt__p_wxXPMHandler,
37942 };
37943
37944 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37945 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37946 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37947 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37948 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37949 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37950 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37951 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37952 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37953 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}};
37954 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37955 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37956 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37957 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37958 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37959 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37960 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37961 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37962 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}};
37963 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37964 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37965 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37966 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37967 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37968 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}};
37969 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37970 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}};
37971 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37972 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37973 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37974 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37975 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37976 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37977 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37978 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37979 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37980 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37981 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37982 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37983 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37984 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37985 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37986 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37987 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37988 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37989 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37990 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37991 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37992 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37993 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37994 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37995 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
37996 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37997 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37998 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37999 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38000 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38001 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38002 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38003 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
38004 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38005 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38006 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
38007 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38008 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38009 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
38010 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38011 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38012 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
38013 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}};
38014 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
38015 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
38016 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
38017 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
38018 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
38019 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
38020 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}};
38021 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
38022 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38023 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
38024 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
38025 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
38026 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
38027 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
38028 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
38029 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
38030 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
38031 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
38032 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}};
38033 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
38034 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
38035 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
38036 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
38037 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
38038 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38039 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
38040 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
38041 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
38042 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
38043 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38044 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
38045 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
38046 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
38047 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
38048 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38049 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38050 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
38051 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38052 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38053 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
38054 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38055 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38056 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38057 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38058 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38059 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38060 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38061 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38062 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38063 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38064 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38065 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38066 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38067 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38068 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38069 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38070 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38071 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38072 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38073 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38074 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38075 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38076 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38077 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}};
38078 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38079 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38080 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38081 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38082 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38083 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38084 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38085 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38086 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38087 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}};
38088 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38089 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38090 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38091 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38092 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38093 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38094 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38095 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38096 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38097 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38098 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38099 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38100 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38101 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38102 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38103 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38104 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38105 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}};
38106 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38107 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38108 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38109 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38110 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}};
38111 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38112 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38113 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38114 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}};
38115 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38116
38117 static swig_cast_info *swig_cast_initial[] = {
38118 _swigc__p_char,
38119 _swigc__p_form_ops_t,
38120 _swigc__p_int,
38121 _swigc__p_unsigned_char,
38122 _swigc__p_unsigned_int,
38123 _swigc__p_unsigned_long,
38124 _swigc__p_void,
38125 _swigc__p_wxANIHandler,
38126 _swigc__p_wxAcceleratorTable,
38127 _swigc__p_wxActivateEvent,
38128 _swigc__p_wxArrayString,
38129 _swigc__p_wxBMPHandler,
38130 _swigc__p_wxBitmap,
38131 _swigc__p_wxBitmapDataObject,
38132 _swigc__p_wxBoxSizer,
38133 _swigc__p_wxBusyCursor,
38134 _swigc__p_wxBusyInfo,
38135 _swigc__p_wxCURHandler,
38136 _swigc__p_wxCaret,
38137 _swigc__p_wxChar,
38138 _swigc__p_wxChildFocusEvent,
38139 _swigc__p_wxClipboard,
38140 _swigc__p_wxClipboardLocker,
38141 _swigc__p_wxClipboardTextEvent,
38142 _swigc__p_wxCloseEvent,
38143 _swigc__p_wxColour,
38144 _swigc__p_wxCommandEvent,
38145 _swigc__p_wxConfig,
38146 _swigc__p_wxConfigBase,
38147 _swigc__p_wxConfigPathChanger,
38148 _swigc__p_wxContextMenuEvent,
38149 _swigc__p_wxControl,
38150 _swigc__p_wxControlWithItems,
38151 _swigc__p_wxCursor,
38152 _swigc__p_wxCustomDataObject,
38153 _swigc__p_wxDC,
38154 _swigc__p_wxDataFormat,
38155 _swigc__p_wxDataObject,
38156 _swigc__p_wxDataObjectComposite,
38157 _swigc__p_wxDataObjectSimple,
38158 _swigc__p_wxDateEvent,
38159 _swigc__p_wxDateSpan,
38160 _swigc__p_wxDateTime,
38161 _swigc__p_wxDateTime__TimeZone,
38162 _swigc__p_wxDisplay,
38163 _swigc__p_wxDisplayChangedEvent,
38164 _swigc__p_wxDropFilesEvent,
38165 _swigc__p_wxDuplexMode,
38166 _swigc__p_wxEraseEvent,
38167 _swigc__p_wxEvent,
38168 _swigc__p_wxEvtHandler,
38169 _swigc__p_wxFSFile,
38170 _swigc__p_wxFileConfig,
38171 _swigc__p_wxFileDataObject,
38172 _swigc__p_wxFileHistory,
38173 _swigc__p_wxFileSystem,
38174 _swigc__p_wxFileType,
38175 _swigc__p_wxFileTypeInfo,
38176 _swigc__p_wxFlexGridSizer,
38177 _swigc__p_wxFocusEvent,
38178 _swigc__p_wxFont,
38179 _swigc__p_wxFrame,
38180 _swigc__p_wxGBSizerItem,
38181 _swigc__p_wxGIFHandler,
38182 _swigc__p_wxGridBagSizer,
38183 _swigc__p_wxGridSizer,
38184 _swigc__p_wxICOHandler,
38185 _swigc__p_wxIcon,
38186 _swigc__p_wxIconizeEvent,
38187 _swigc__p_wxIdleEvent,
38188 _swigc__p_wxImage,
38189 _swigc__p_wxImageHandler,
38190 _swigc__p_wxIndividualLayoutConstraint,
38191 _swigc__p_wxInitDialogEvent,
38192 _swigc__p_wxJPEGHandler,
38193 _swigc__p_wxJoystick,
38194 _swigc__p_wxJoystickEvent,
38195 _swigc__p_wxKeyEvent,
38196 _swigc__p_wxKillError,
38197 _swigc__p_wxLayoutConstraints,
38198 _swigc__p_wxLog,
38199 _swigc__p_wxLogBuffer,
38200 _swigc__p_wxLogChain,
38201 _swigc__p_wxLogGui,
38202 _swigc__p_wxLogNull,
38203 _swigc__p_wxLogStderr,
38204 _swigc__p_wxLogTextCtrl,
38205 _swigc__p_wxLogWindow,
38206 _swigc__p_wxMaximizeEvent,
38207 _swigc__p_wxMemorySize,
38208 _swigc__p_wxMenu,
38209 _swigc__p_wxMenuBar,
38210 _swigc__p_wxMenuEvent,
38211 _swigc__p_wxMenuItem,
38212 _swigc__p_wxMetafile,
38213 _swigc__p_wxMetafileDataObject,
38214 _swigc__p_wxMimeTypesManager,
38215 _swigc__p_wxMouseCaptureChangedEvent,
38216 _swigc__p_wxMouseEvent,
38217 _swigc__p_wxMouseState,
38218 _swigc__p_wxMoveEvent,
38219 _swigc__p_wxMutexGuiLocker,
38220 _swigc__p_wxNavigationKeyEvent,
38221 _swigc__p_wxNcPaintEvent,
38222 _swigc__p_wxNotifyEvent,
38223 _swigc__p_wxObject,
38224 _swigc__p_wxOutputStream,
38225 _swigc__p_wxPCXHandler,
38226 _swigc__p_wxPNGHandler,
38227 _swigc__p_wxPNMHandler,
38228 _swigc__p_wxPaintEvent,
38229 _swigc__p_wxPaletteChangedEvent,
38230 _swigc__p_wxPaperSize,
38231 _swigc__p_wxPoint,
38232 _swigc__p_wxPowerEvent,
38233 _swigc__p_wxProcessEvent,
38234 _swigc__p_wxPyApp,
38235 _swigc__p_wxPyArtProvider,
38236 _swigc__p_wxPyBitmapDataObject,
38237 _swigc__p_wxPyCommandEvent,
38238 _swigc__p_wxPyDataObjectSimple,
38239 _swigc__p_wxPyDropSource,
38240 _swigc__p_wxPyDropTarget,
38241 _swigc__p_wxPyEvent,
38242 _swigc__p_wxPyFileDropTarget,
38243 _swigc__p_wxPyImageHandler,
38244 _swigc__p_wxPyLog,
38245 _swigc__p_wxPyProcess,
38246 _swigc__p_wxPySizer,
38247 _swigc__p_wxPyTextDataObject,
38248 _swigc__p_wxPyTextDropTarget,
38249 _swigc__p_wxPyTimer,
38250 _swigc__p_wxPyTipProvider,
38251 _swigc__p_wxPyValidator,
38252 _swigc__p_wxQueryNewPaletteEvent,
38253 _swigc__p_wxRect,
38254 _swigc__p_wxScrollEvent,
38255 _swigc__p_wxScrollWinEvent,
38256 _swigc__p_wxSetCursorEvent,
38257 _swigc__p_wxShowEvent,
38258 _swigc__p_wxSingleInstanceChecker,
38259 _swigc__p_wxSize,
38260 _swigc__p_wxSizeEvent,
38261 _swigc__p_wxSizer,
38262 _swigc__p_wxSizerItem,
38263 _swigc__p_wxSound,
38264 _swigc__p_wxStandardPaths,
38265 _swigc__p_wxStaticBoxSizer,
38266 _swigc__p_wxStdDialogButtonSizer,
38267 _swigc__p_wxStopWatch,
38268 _swigc__p_wxString,
38269 _swigc__p_wxSysColourChangedEvent,
38270 _swigc__p_wxSystemOptions,
38271 _swigc__p_wxSystemSettings,
38272 _swigc__p_wxTIFFHandler,
38273 _swigc__p_wxTextCtrl,
38274 _swigc__p_wxTextDataObject,
38275 _swigc__p_wxTimeSpan,
38276 _swigc__p_wxTimer,
38277 _swigc__p_wxTimerEvent,
38278 _swigc__p_wxTimerRunner,
38279 _swigc__p_wxTipProvider,
38280 _swigc__p_wxToolTip,
38281 _swigc__p_wxURLDataObject,
38282 _swigc__p_wxUpdateUIEvent,
38283 _swigc__p_wxValidator,
38284 _swigc__p_wxVideoMode,
38285 _swigc__p_wxWindow,
38286 _swigc__p_wxWindowCreateEvent,
38287 _swigc__p_wxWindowDestroyEvent,
38288 _swigc__p_wxWindowDisabler,
38289 _swigc__p_wxXPMHandler,
38290 };
38291
38292
38293 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38294
38295 static swig_const_info swig_const_table[] = {
38296 {0, 0, 0, 0.0, 0, 0}};
38297
38298 #ifdef __cplusplus
38299 }
38300 #endif
38301 /* -----------------------------------------------------------------------------
38302 * Type initialization:
38303 * This problem is tough by the requirement that no dynamic
38304 * memory is used. Also, since swig_type_info structures store pointers to
38305 * swig_cast_info structures and swig_cast_info structures store pointers back
38306 * to swig_type_info structures, we need some lookup code at initialization.
38307 * The idea is that swig generates all the structures that are needed.
38308 * The runtime then collects these partially filled structures.
38309 * The SWIG_InitializeModule function takes these initial arrays out of
38310 * swig_module, and does all the lookup, filling in the swig_module.types
38311 * array with the correct data and linking the correct swig_cast_info
38312 * structures together.
38313 *
38314 * The generated swig_type_info structures are assigned staticly to an initial
38315 * array. We just loop though that array, and handle each type individually.
38316 * First we lookup if this type has been already loaded, and if so, use the
38317 * loaded structure instead of the generated one. Then we have to fill in the
38318 * cast linked list. The cast data is initially stored in something like a
38319 * two-dimensional array. Each row corresponds to a type (there are the same
38320 * number of rows as there are in the swig_type_initial array). Each entry in
38321 * a column is one of the swig_cast_info structures for that type.
38322 * The cast_initial array is actually an array of arrays, because each row has
38323 * a variable number of columns. So to actually build the cast linked list,
38324 * we find the array of casts associated with the type, and loop through it
38325 * adding the casts to the list. The one last trick we need to do is making
38326 * sure the type pointer in the swig_cast_info struct is correct.
38327 *
38328 * First off, we lookup the cast->type name to see if it is already loaded.
38329 * There are three cases to handle:
38330 * 1) If the cast->type has already been loaded AND the type we are adding
38331 * casting info to has not been loaded (it is in this module), THEN we
38332 * replace the cast->type pointer with the type pointer that has already
38333 * been loaded.
38334 * 2) If BOTH types (the one we are adding casting info to, and the
38335 * cast->type) are loaded, THEN the cast info has already been loaded by
38336 * the previous module so we just ignore it.
38337 * 3) Finally, if cast->type has not already been loaded, then we add that
38338 * swig_cast_info to the linked list (because the cast->type) pointer will
38339 * be correct.
38340 * ----------------------------------------------------------------------------- */
38341
38342 #ifdef __cplusplus
38343 extern "C" {
38344 #if 0
38345 } /* c-mode */
38346 #endif
38347 #endif
38348
38349 #if 0
38350 #define SWIGRUNTIME_DEBUG
38351 #endif
38352
38353 SWIGRUNTIME void
38354 SWIG_InitializeModule(void *clientdata) {
38355 size_t i;
38356 swig_module_info *module_head;
38357 static int init_run = 0;
38358
38359 clientdata = clientdata;
38360
38361 if (init_run) return;
38362 init_run = 1;
38363
38364 /* Initialize the swig_module */
38365 swig_module.type_initial = swig_type_initial;
38366 swig_module.cast_initial = swig_cast_initial;
38367
38368 /* Try and load any already created modules */
38369 module_head = SWIG_GetModule(clientdata);
38370 if (module_head) {
38371 swig_module.next = module_head->next;
38372 module_head->next = &swig_module;
38373 } else {
38374 /* This is the first module loaded */
38375 swig_module.next = &swig_module;
38376 SWIG_SetModule(clientdata, &swig_module);
38377 }
38378
38379 /* Now work on filling in swig_module.types */
38380 #ifdef SWIGRUNTIME_DEBUG
38381 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38382 #endif
38383 for (i = 0; i < swig_module.size; ++i) {
38384 swig_type_info *type = 0;
38385 swig_type_info *ret;
38386 swig_cast_info *cast;
38387
38388 #ifdef SWIGRUNTIME_DEBUG
38389 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38390 #endif
38391
38392 /* if there is another module already loaded */
38393 if (swig_module.next != &swig_module) {
38394 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38395 }
38396 if (type) {
38397 /* Overwrite clientdata field */
38398 #ifdef SWIGRUNTIME_DEBUG
38399 printf("SWIG_InitializeModule: found type %s\n", type->name);
38400 #endif
38401 if (swig_module.type_initial[i]->clientdata) {
38402 type->clientdata = swig_module.type_initial[i]->clientdata;
38403 #ifdef SWIGRUNTIME_DEBUG
38404 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38405 #endif
38406 }
38407 } else {
38408 type = swig_module.type_initial[i];
38409 }
38410
38411 /* Insert casting types */
38412 cast = swig_module.cast_initial[i];
38413 while (cast->type) {
38414 /* Don't need to add information already in the list */
38415 ret = 0;
38416 #ifdef SWIGRUNTIME_DEBUG
38417 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38418 #endif
38419 if (swig_module.next != &swig_module) {
38420 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38421 #ifdef SWIGRUNTIME_DEBUG
38422 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38423 #endif
38424 }
38425 if (ret) {
38426 if (type == swig_module.type_initial[i]) {
38427 #ifdef SWIGRUNTIME_DEBUG
38428 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38429 #endif
38430 cast->type = ret;
38431 ret = 0;
38432 } else {
38433 /* Check for casting already in the list */
38434 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38435 #ifdef SWIGRUNTIME_DEBUG
38436 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38437 #endif
38438 if (!ocast) ret = 0;
38439 }
38440 }
38441
38442 if (!ret) {
38443 #ifdef SWIGRUNTIME_DEBUG
38444 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38445 #endif
38446 if (type->cast) {
38447 type->cast->prev = cast;
38448 cast->next = type->cast;
38449 }
38450 type->cast = cast;
38451 }
38452 cast++;
38453 }
38454 /* Set entry in modules->types array equal to the type */
38455 swig_module.types[i] = type;
38456 }
38457 swig_module.types[i] = 0;
38458
38459 #ifdef SWIGRUNTIME_DEBUG
38460 printf("**** SWIG_InitializeModule: Cast List ******\n");
38461 for (i = 0; i < swig_module.size; ++i) {
38462 int j = 0;
38463 swig_cast_info *cast = swig_module.cast_initial[i];
38464 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38465 while (cast->type) {
38466 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38467 cast++;
38468 ++j;
38469 }
38470 printf("---- Total casts: %d\n",j);
38471 }
38472 printf("**** SWIG_InitializeModule: Cast List ******\n");
38473 #endif
38474 }
38475
38476 /* This function will propagate the clientdata field of type to
38477 * any new swig_type_info structures that have been added into the list
38478 * of equivalent types. It is like calling
38479 * SWIG_TypeClientData(type, clientdata) a second time.
38480 */
38481 SWIGRUNTIME void
38482 SWIG_PropagateClientData(void) {
38483 size_t i;
38484 swig_cast_info *equiv;
38485 static int init_run = 0;
38486
38487 if (init_run) return;
38488 init_run = 1;
38489
38490 for (i = 0; i < swig_module.size; i++) {
38491 if (swig_module.types[i]->clientdata) {
38492 equiv = swig_module.types[i]->cast;
38493 while (equiv) {
38494 if (!equiv->converter) {
38495 if (equiv->type && !equiv->type->clientdata)
38496 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38497 }
38498 equiv = equiv->next;
38499 }
38500 }
38501 }
38502 }
38503
38504 #ifdef __cplusplus
38505 #if 0
38506 {
38507 /* c-mode */
38508 #endif
38509 }
38510 #endif
38511
38512
38513
38514 #ifdef __cplusplus
38515 extern "C" {
38516 #endif
38517
38518 /* Python-specific SWIG API */
38519 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38520 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38521 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38522
38523 /* -----------------------------------------------------------------------------
38524 * global variable support code.
38525 * ----------------------------------------------------------------------------- */
38526
38527 typedef struct swig_globalvar {
38528 char *name; /* Name of global variable */
38529 PyObject *(*get_attr)(void); /* Return the current value */
38530 int (*set_attr)(PyObject *); /* Set the value */
38531 struct swig_globalvar *next;
38532 } swig_globalvar;
38533
38534 typedef struct swig_varlinkobject {
38535 PyObject_HEAD
38536 swig_globalvar *vars;
38537 } swig_varlinkobject;
38538
38539 SWIGINTERN PyObject *
38540 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38541 return PyString_FromString("<Swig global variables>");
38542 }
38543
38544 SWIGINTERN PyObject *
38545 swig_varlink_str(swig_varlinkobject *v) {
38546 PyObject *str = PyString_FromString("(");
38547 swig_globalvar *var;
38548 for (var = v->vars; var; var=var->next) {
38549 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38550 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38551 }
38552 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38553 return str;
38554 }
38555
38556 SWIGINTERN int
38557 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38558 PyObject *str = swig_varlink_str(v);
38559 fprintf(fp,"Swig global variables ");
38560 fprintf(fp,"%s\n", PyString_AsString(str));
38561 Py_DECREF(str);
38562 return 0;
38563 }
38564
38565 SWIGINTERN void
38566 swig_varlink_dealloc(swig_varlinkobject *v) {
38567 swig_globalvar *var = v->vars;
38568 while (var) {
38569 swig_globalvar *n = var->next;
38570 free(var->name);
38571 free(var);
38572 var = n;
38573 }
38574 }
38575
38576 SWIGINTERN PyObject *
38577 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38578 PyObject *res = NULL;
38579 swig_globalvar *var = v->vars;
38580 while (var) {
38581 if (strcmp(var->name,n) == 0) {
38582 res = (*var->get_attr)();
38583 break;
38584 }
38585 var = var->next;
38586 }
38587 if (res == NULL && !PyErr_Occurred()) {
38588 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38589 }
38590 return res;
38591 }
38592
38593 SWIGINTERN int
38594 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38595 int res = 1;
38596 swig_globalvar *var = v->vars;
38597 while (var) {
38598 if (strcmp(var->name,n) == 0) {
38599 res = (*var->set_attr)(p);
38600 break;
38601 }
38602 var = var->next;
38603 }
38604 if (res == 1 && !PyErr_Occurred()) {
38605 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38606 }
38607 return res;
38608 }
38609
38610 SWIGINTERN PyTypeObject*
38611 swig_varlink_type(void) {
38612 static char varlink__doc__[] = "Swig var link object";
38613 static PyTypeObject varlink_type;
38614 static int type_init = 0;
38615 if (!type_init) {
38616 const PyTypeObject tmp
38617 = {
38618 PyObject_HEAD_INIT(NULL)
38619 0, /* Number of items in variable part (ob_size) */
38620 (char *)"swigvarlink", /* Type name (tp_name) */
38621 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38622 0, /* Itemsize (tp_itemsize) */
38623 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38624 (printfunc) swig_varlink_print, /* Print (tp_print) */
38625 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38626 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38627 0, /* tp_compare */
38628 (reprfunc) swig_varlink_repr, /* tp_repr */
38629 0, /* tp_as_number */
38630 0, /* tp_as_sequence */
38631 0, /* tp_as_mapping */
38632 0, /* tp_hash */
38633 0, /* tp_call */
38634 (reprfunc)swig_varlink_str, /* tp_str */
38635 0, /* tp_getattro */
38636 0, /* tp_setattro */
38637 0, /* tp_as_buffer */
38638 0, /* tp_flags */
38639 varlink__doc__, /* tp_doc */
38640 0, /* tp_traverse */
38641 0, /* tp_clear */
38642 0, /* tp_richcompare */
38643 0, /* tp_weaklistoffset */
38644 #if PY_VERSION_HEX >= 0x02020000
38645 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38646 #endif
38647 #if PY_VERSION_HEX >= 0x02030000
38648 0, /* tp_del */
38649 #endif
38650 #ifdef COUNT_ALLOCS
38651 0,0,0,0 /* tp_alloc -> tp_next */
38652 #endif
38653 };
38654 varlink_type = tmp;
38655 varlink_type.ob_type = &PyType_Type;
38656 type_init = 1;
38657 }
38658 return &varlink_type;
38659 }
38660
38661 /* Create a variable linking object for use later */
38662 SWIGINTERN PyObject *
38663 SWIG_Python_newvarlink(void) {
38664 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38665 if (result) {
38666 result->vars = 0;
38667 }
38668 return ((PyObject*) result);
38669 }
38670
38671 SWIGINTERN void
38672 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38673 swig_varlinkobject *v = (swig_varlinkobject *) p;
38674 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38675 if (gv) {
38676 size_t size = strlen(name)+1;
38677 gv->name = (char *)malloc(size);
38678 if (gv->name) {
38679 strncpy(gv->name,name,size);
38680 gv->get_attr = get_attr;
38681 gv->set_attr = set_attr;
38682 gv->next = v->vars;
38683 }
38684 }
38685 v->vars = gv;
38686 }
38687
38688 SWIGINTERN PyObject *
38689 SWIG_globals() {
38690 static PyObject *_SWIG_globals = 0;
38691 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38692 return _SWIG_globals;
38693 }
38694
38695 /* -----------------------------------------------------------------------------
38696 * constants/methods manipulation
38697 * ----------------------------------------------------------------------------- */
38698
38699 /* Install Constants */
38700 SWIGINTERN void
38701 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38702 PyObject *obj = 0;
38703 size_t i;
38704 for (i = 0; constants[i].type; ++i) {
38705 switch(constants[i].type) {
38706 case SWIG_PY_POINTER:
38707 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38708 break;
38709 case SWIG_PY_BINARY:
38710 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38711 break;
38712 default:
38713 obj = 0;
38714 break;
38715 }
38716 if (obj) {
38717 PyDict_SetItemString(d, constants[i].name, obj);
38718 Py_DECREF(obj);
38719 }
38720 }
38721 }
38722
38723 /* -----------------------------------------------------------------------------*/
38724 /* Fix SwigMethods to carry the callback ptrs when needed */
38725 /* -----------------------------------------------------------------------------*/
38726
38727 SWIGINTERN void
38728 SWIG_Python_FixMethods(PyMethodDef *methods,
38729 swig_const_info *const_table,
38730 swig_type_info **types,
38731 swig_type_info **types_initial) {
38732 size_t i;
38733 for (i = 0; methods[i].ml_name; ++i) {
38734 char *c = methods[i].ml_doc;
38735 if (c && (c = strstr(c, "swig_ptr: "))) {
38736 int j;
38737 swig_const_info *ci = 0;
38738 char *name = c + 10;
38739 for (j = 0; const_table[j].type; ++j) {
38740 if (strncmp(const_table[j].name, name,
38741 strlen(const_table[j].name)) == 0) {
38742 ci = &(const_table[j]);
38743 break;
38744 }
38745 }
38746 if (ci) {
38747 size_t shift = (ci->ptype) - types;
38748 swig_type_info *ty = types_initial[shift];
38749 size_t ldoc = (c - methods[i].ml_doc);
38750 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38751 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38752 if (ndoc) {
38753 char *buff = ndoc;
38754 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38755 if (ptr) {
38756 strncpy(buff, methods[i].ml_doc, ldoc);
38757 buff += ldoc;
38758 strncpy(buff, "swig_ptr: ", 10);
38759 buff += 10;
38760 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38761 methods[i].ml_doc = ndoc;
38762 }
38763 }
38764 }
38765 }
38766 }
38767 }
38768
38769 #ifdef __cplusplus
38770 }
38771 #endif
38772
38773 /* -----------------------------------------------------------------------------*
38774 * Partial Init method
38775 * -----------------------------------------------------------------------------*/
38776
38777 #ifdef __cplusplus
38778 extern "C"
38779 #endif
38780 SWIGEXPORT void SWIG_init(void) {
38781 PyObject *m, *d;
38782
38783 /* Fix SwigMethods to carry the callback ptrs when needed */
38784 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38785
38786 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38787 d = PyModule_GetDict(m);
38788
38789 SWIG_InitializeModule(0);
38790 SWIG_InstallConstants(d,swig_const_table);
38791
38792
38793 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38794 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38795 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38796 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38797 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38798 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38799 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38800 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38801 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38802 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38803 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38804 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38805 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38806 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38807 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38808 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38809 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38810 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38811 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38812 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38813 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38814 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38815 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38816 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38817 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38818 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38819 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38820 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38821 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38822 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38823 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38824 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38825 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38826 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38827 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38828 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38829 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38830 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38831 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38832 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38833 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38834 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38835 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38836 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38837 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38838 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38839 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38840 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38841 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38842 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38843 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38844 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38845 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38846 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38847 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38848 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38849 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38850 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38851 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38852 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38853 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38854 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38855 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38856 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38857 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38858 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38859 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38860 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38861 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38862 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38863 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38864 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38865 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38866 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38867 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38868 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38869 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38870 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38871 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38872 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38873 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38874 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38875 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38876 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38877 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38878 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38879 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38880 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38881 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38882 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38883 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38884 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38885 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38886 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38887 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38888 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38889 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38890 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38891 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38892 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38893 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38894 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38895
38896 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38897
38898 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38899 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38900 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38901 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38902 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38903 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38904 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38905 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38906 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38907 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38908 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38909 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38910 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38911 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38912 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38913 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38914 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38915 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38916 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38917 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38918 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38919 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38920 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38921 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38922 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38923 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38924 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38925 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38926 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38927 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38928 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38929 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38930 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38931 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38932 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38933 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38934 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38935 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38936 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38937 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38938 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38939 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38940 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38941 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38942 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38943 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38944 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38945 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38946 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38947 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38948 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38949 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38950 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38951
38952 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38953
38954 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38955 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38956 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38957 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38958 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38959 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38960 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38961 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38962 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38963 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38964 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38965 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38966 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38967 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38968 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38969 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38970 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38971 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38972 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38973 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38974 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38975 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38976 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38977 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38978 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38979 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38980 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38981 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38982 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38983 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38984 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38985 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38986 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38987 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38988 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38989 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38990 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38991 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38992 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38993 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38994 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38995 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38996 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38997 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38998 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38999 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
39000 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
39001 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
39002 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
39003 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
39004 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
39005 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
39006 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
39007 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
39008 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
39009 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
39010 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
39011 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
39012 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
39013 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
39014 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
39015 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
39016 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
39017 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
39018 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
39019 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
39020 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
39021 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
39022 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
39023 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
39024 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
39025 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
39026 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
39027 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39028 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39029 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39030
39031 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39032
39033 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39034 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39035 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39036 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39037 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39038 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39039 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39040 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39041 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39042 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39043 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39044 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39045 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39046 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39047 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39048 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39049 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39050 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39051 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39052 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39053 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39054 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39055 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39056 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39057 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39058 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39059 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39060 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39061 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39062 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39063 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39064 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39065 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39066 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39067 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39068 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39069 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39070 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39071 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39072 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39073 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39074 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39075 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39076 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39077 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39078 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39079 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39080 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39081 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39082 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39083 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39084 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39085 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39086 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39087 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39088 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39089 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39090 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39091 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39092 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39093 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39094 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39095 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39096 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39097 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39098 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39099 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39100 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39101 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39102 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39103 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39104 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39105 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39106 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39107 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39108 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39109 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39110 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39111 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39112 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39113 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39114 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39115 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39116 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39117 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39118 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39119 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39120 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39121 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39122 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39123 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39124 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39125 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39126 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39127 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39128 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39129 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39130 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39131 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39132 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39133 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39134 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39135 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39136 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39137 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39138 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39139 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39140 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39141 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39142 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39143 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39144 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39145 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39146 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39147 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39148 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39149 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39150 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39151 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39152 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39153 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39154 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39155 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39156 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39157 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39158 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39159 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39160 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39161 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39162 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39163 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39164 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39165 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39166 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39167 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39168 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39169 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39170 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39171 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39172 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39173 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39174 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39175 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39176 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39177 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39178 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39179 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39180 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39181 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39182 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39183 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39184 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39185 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39186 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39187 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39188 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39189 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39190 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39191 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39192 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39193 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39194 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39195 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39196 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39197 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39198 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39199 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39200 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39201 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39202 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39203 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39204 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39205 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39206 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39207 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39208 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39209 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39210 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39211 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39212 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39213 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39214 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39215 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39216 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39217 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39218 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39219 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39220 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39221 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39222 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39223 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39224 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39225 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39226 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39227 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39228 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39229 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39230 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39231 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39232 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39233
39234 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39235 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39236 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39237 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39238
39239 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39240 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39241 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39242 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39243 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39244 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39245 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39246 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39247 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39248 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39249 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39250 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39251 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39252 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39253 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39254 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39255 }
39256
wxWidgets (Impactor)